diff --git a/README.md b/README.md
index 3cb9fc7..a1cc918 100644
--- a/README.md
+++ b/README.md
@@ -2,281 +2,529 @@
 
 A batch downloader for Soulseek built with Soulseek.NET. Accepts CSV files and Spotify or YouTube urls.
 
+## Index
+- [slsk-batchdl](#slsk-batchdl)
+  - [Options](#options)
+  - [Input types](#input-types)
+    - [CSV file](#csv-file)
+    - [YouTube](#youtube)
+    - [Spotify](#spotify)
+    - [Bandcamp](#bandcamp)
+    - [Search string](#search-string)
+  - [Download modes](#download-modes)
+    - [Normal](#normal)
+    - [Album](#album)
+    - [Aggregate](#aggregate)
+    - [Album Aggregate](#album-aggregate)
+  - [Searching](#searching)
+  - [File conditions](#file-conditions)
+  - [Name format](#name-format)
+  - [Skip existing](#skip-existing)
+  - [Configuration](#configuration)
+  - [Examples](#examples-1)
+  - [Notes](#notes)
+
+
+## Options
+
+```
+Usage: sldl <input> [OPTIONS]
+
+  Required Arguments
+    <input>                        A url, search string, or path to a local CSV file.
+                                   Run --help "input" to view the accepted inputs.
+                                   Can also be passed with -i, --input <input>
+    --user <username>              Soulseek username
+    --pass <password>              Soulseek password
+```
+```
+  General Options
+    -p, --path <path>              Download directory
+    -f, --folder <name>            Subfolder name. Set to '.' to output directly to --path
+    --input-type <type>            Force set input type, [csv|youtube|spotify|bandcamp|string]
+    --name-format <format>         Name format for downloaded tracks. See --help name-format
+
+    -n, --number <maxtracks>       Download the first n tracks of a playlist
+    -o, --offset <offset>          Skip a specified number of tracks
+    -r, --reverse                  Download tracks in reverse order
+    -c, --config <path>            Set config file location. Set to 'none' to ignore config
+    --profile <name>               Configuration profile to use. See --help "config".
+    --concurrent-downloads <num>   Max concurrent downloads (default: 2)
+    --m3u <option>                 Create an m3u8 playlist file in the output directory
+                                   'none' (default for single inputs): Do not create
+                                   'index' (default): Write a line indexing all downloaded
+                                   files, required for skip-not-found or skip-existing=m3u
+                                   'all': Write the index and a list of paths and fails
+
+    -s, --skip-existing            Skip if a track matching file conditions is found in the
+                                   output folder or your music library (if provided)
+    --skip-mode <mode>             [name|tag|m3u|name-cond|tag-cond|m3u-cond]
+                                   See --help "skip-existing".
+    --music-dir <path>             Specify to also skip downloading tracks found in a music
+                                   library. Use with --skip-existing
+    --skip-not-found               Skip searching for tracks that weren't found on Soulseek
+                                   during the last run. Fails are read from the m3u file.
+
+    --display-mode <option>        Changes how searches and downloads are displayed:
+                                   'single' (default): Show transfer state and percentage
+                                   'double': Transfer state and a large progress bar
+                                   'simple': No download bars or changing percentages
+    --print <option>               Print tracks or search results instead of downloading:
+                                   'tracks': Print all tracks to be downloaded
+                                   'tracks-full': Print extended information about all tracks
+                                   'results': Print search results satisfying file conditions
+                                   'results-full': Print search results including full paths
+    --debug                        Print extra debug info
+
+    --listen-port <port>           Port for incoming connections (default: 49998)
+    --on-complete <command>        Run a specified command whenever a file is downloaded.
+                                   Available placeholders: {path} (local save path), {title},
+                                   {artist},{album},{uri},{length},{failure-reason},{state}.
+                                   Prepend a state number to only download in specific cases:
+                                   1:, 2:, 3:, 4: for the Downloaded, Failed, Exists, and
+                                   NotFoundLastTime states respectively.
+                                   E.g: '1:<cmd>' will only run the command if the file is
+                                   downloaded successfully.
+```
+```
+  Searching
+    --fast-search                  Begin downloading as soon as a file satisfying the preferred
+                                   conditions is found. Higher chance to download wrong files.
+    --remove-ft                    Remove 'feat.' and everything after before searching
+    --no-remove-special-chars      Do not remove special characters before searching
+    --remove-brackets              Remove square brackets and their contents before searching
+    --regex <regex>                Remove a regexp from all track titles and artist names.
+                                   Optionally specify a replacement regex after a semicolon.
+                                   Add 'T:', 'A:' or 'L:' at the start to only apply this to
+                                   the track title, artist, or album respectively.
+    --artist-maybe-wrong           Performs an additional search without the artist name.
+                                   Useful for sources like SoundCloud where the "artist"
+                                   could just be an uploader. Note that when downloading a
+                                   YouTube playlist via url, this option is set automatically
+                                   on a per-track basis, so it is best kept off in that case.
+    -d, --desperate                Tries harder to find the desired track by searching for the
+                                   artist/album/title only, then filtering. (slower search)
+    --fails-to-downrank <num>      Number of fails to downrank a user's uploads (default: 1)
+    --fails-to-ignore <num>        Number of fails to ban/ignore a user's uploads (default: 2)
+
+    --yt-dlp                       Use yt-dlp to download tracks that weren't found on
+                                   Soulseek. yt-dlp must be available from the command line.
+    --yt-dlp-argument <str>        The command line arguments when running yt-dlp. Default:
+                                   "{id}" -f bestaudio/best -cix -o "{savepath}.%(ext)s"
+                                   Available vars are: {id}, {savedir}, {savepath} (w/o ext).
+                                   Note that with -x, yt-dlp will download webms in case
+                                   ffmpeg is unavailable.
+
+    --search-timeout <ms>          Max search time in ms (default: 6000)
+    --max-stale-time <ms>          Max download time without progress in ms (default: 50000)
+    --searches-per-time <num>      Max searches per time interval. Higher values may cause
+                                   30-minute bans, see --help "search". (default: 34)
+    --searches-renew-time <sec>    Controls how often available searches are replenished.
+                                   See --help "search". (default: 220)
+```
+```
+  Spotify
+    --spotify-id <id>              spotify client ID
+    --spotify-secret <secret>      spotify client secret
+    --remove-from-source           Remove downloaded tracks from source playlist
+```
+```
+  YouTube
+    --youtube-key <key>            Youtube data API key
+    --get-deleted                  Attempt to retrieve titles of deleted videos from wayback
+                                   machine. Requires yt-dlp.
+    --deleted-only                 Only retrieve & download deleted music.
+```
+```
+  CSV Files
+    --artist-col                   Artist column name
+    --title-col                    Track title column name
+    --album-col                    Album column name
+    --length-col                   Track length column name
+    --album-track-count-col        Album track count column name (sets --album-track-count)
+    --yt-desc-col                  Youtube description column (improves --yt-parse)
+    --yt-id-col                    Youtube video id column (improves --yt-parse)
+
+    --time-format <format>         Time format in Length column of the csv file (e.g h:m:s.ms
+                                   for durations like 1:04:35.123). Default: s
+    --yt-parse                     Enable if the CSV contains YouTube video titles and channel
+                                   names; attempt to parse them into title and artist names.
+    --remove-from-source           Remove downloaded tracks from source CSV file
+```
+```
+  File Conditions
+    --format <formats>             Accepted file format(s), comma-separated, without periods
+    --length-tol <sec>             Length tolerance in seconds
+    --min-bitrate <rate>           Minimum file bitrate
+    --max-bitrate <rate>           Maximum file bitrate
+    --min-samplerate <rate>        Minimum file sample rate
+    --max-samplerate <rate>        Maximum file sample rate
+    --min-bitdepth <depth>         Minimum bit depth
+    --max-bitdepth <depth>         Maximum bit depth
+    --banned-users <list>          Comma-separated list of users to ignore
+
+    --pref-format <formats>        Preferred file format(s), comma-separated (default: mp3)
+    --pref-length-tol <sec>        Preferred length tolerance in seconds (default: 3)
+    --pref-min-bitrate <rate>      Preferred minimum bitrate (default: 200)
+    --pref-max-bitrate <rate>      Preferred maximum bitrate (default: 2500)
+    --pref-min-samplerate <rate>   Preferred minimum sample rate
+    --pref-max-samplerate <rate>   Preferred maximum sample rate (default: 48000)
+    --pref-min-bitdepth <depth>    Preferred minimum bit depth
+    --pref-max-bitdepth <depth>    Preferred maximum bit depth
+    --pref-banned-users <list>     Comma-separated list of users to downrank
+
+    --strict-conditions            Skip files with missing properties instead of accepting by
+                                   default; if --min-bitrate is set, ignores any files with
+                                   unknown bitrate.
+```
+```
+  Album Download
+    -a, --album                    Album download mode
+    -t, --interactive              Allows to select the wanted folder and images
+    --album-track-count <num>      Specify the exact number of tracks in the album. Add a + or
+                                   - for inequalities, e.g '5+' for five or more tracks.
+    --album-ignore-fails           Do not skip to the next source and do not delete all
+                                   successfully downloaded files if one of the files in the
+                                   folder fails to download
+    --album-art <option>           Retrieve additional images after downloading the album:
+                                   'default': No additional images
+                                   'largest': Download from the folder with the largest image
+                                   'most': Download from the folder containing the most images
+                                   'most-largest': Do most, then largest
+    --album-art-only               Only download album art for the provided album
+    --no-browse-folder             Do not automatically browse user shares to get all files in
+                                   in the folder
+```
+```
+    -g, --aggregate                Aggregate download mode: Find and download all distinct
+                                   songs associated with the provided artist, album, or title.
+    --min-users-aggregate <num>    Minimum number of users sharing a track or album for it to
+                                   be downloaded in aggregate mode. (Default: 2)
+    --relax-filtering              Slightly relax file filtering in aggregate mode to include
+                                   more results
+```
+```
+  Help
+    -h, --help [option]            [all|input|download-modes|search|name-format|
+                                   file-conditions|skip-existing|config]
+```
+```
+  Notes
+    Acronyms of two- and --three-word-flags are also accepted, e.g. --twf. If the option
+    contains the word 'max' then the m should be uppercase. 'bitrate', 'sameplerate' and
+    'bitdepth' should be all treated as two separate words, e.g --Mbr for --max-bitrate.
+
+    Flags can be explicitly disabled by setting them to false, e.g '--interactive false'
+```
+
+## Input types
+
+The input type is usually determined automatically. To force a specific input type, set
+--input-type [spotify|youtube|csv|string|bandcamp]. The following input types are available:
+
+###  CSV file
+Path to a local CSV file: Use a csv file containing track info of the songs to download.
+The names of the columns should be Artist, Title, Album, Length, although alternative names
+are usually detected as well. Only the title or album column is required, but extra info may
+improve search results. Every row that does not have a title column text will be treated as an
+album download.
+
+###  YouTube
+A playlist url: Download songs from a youtube playlist.
+The default method to retrieve playlists doesn't always return all videos, especially not
+the ones which are unavailable. To get all video titles, you can use the official API by
+providing a key with --youtube-key. Get it here https://console.cloud.google.com. Create a
+new project, click "Enable Api" and search for "youtube data", then follow the prompts.
+
+Tip: For playlists containing music videos, it may be better to remove all text in parentheses
+(to remove (Lyrics), (Official), etc) and disable song duration checking:
+--regex "[\[\(].*?[\]\)]" --pref-length-tol -1
+
+### Spotify
+A playlist/album url or 'spotify-likes': Download a spotify playlist, album, or your
+liked songs. --spotify-id and --spotify-secret are required in addition when downloading
+a private playlist or liked music.
+The id and secret can be obtained at https://developer.spotify.com/dashboard/applications.
+Create an app and add http://localhost:48721/callback as a redirect url in its settings.
+
+### Bandcamp
+An bandcamp url: Download a single track, and album, or an artist's entire discography. 
+Extracts the artist name, album name and sets --album-track-count=""n+"", where n is the 
+number of visible tracks on the bandcamp page.
+
+### Search string
+Name of the track, album, or artist to search for: Can either be any typical search string
+(like what you would enter into the soulseek search bar), or a comma-separated list of
+properties like 'title=Song Name, artist=Artist Name, length=215'.
+
+The following properties are allowed:
+```
+title
+artist
+album
+length (in seconds)
+artist-maybe-wrong
+```
+Example inputs and their interpretations:
+  ```
+Input String                            | Artist   | Title    | Album    | Length
+---------------------------------------------------------------------------------
+'Foo Bar'   (without any hyphens)       |          | Foo Bar  |          |
+'Foo - Bar'                             | Foo      | Bar      |          |
+'Foo - Bar' (with --album enabled)      | Foo      |          | Bar      |
+'Artist - Title, length=42'             | Artist   | Title    |          | 42
+'artist=AR, title=T, album=AL'          | AR       | T        | AL       |
+```
+
+## Download modes
+
+### Normal
+  The program will download a single file for every input entry.
+
+### Album
+  The program will search for the album and download an entire folder including non-audio
+  files. Activated when the input is a link to a spotify or bandcamp album, when the input
+  string or csv row has no track title, or when -a/--album is enabled.
+
+### Aggregate
+  With -g/--aggregate, the program will first perform an ordinary search for the input, then
+  attempt to group the results into distinct songs and download one of each kind. A common use
+  case is finding all remixes of a song or printing all songs by an artist that are not your
+  music dir.  
+  Two files are considered equal if their inferred track title and artist name are equal
+  (ignoring case and some special characters), and their lengths are within --length-tol of each
+  other.  
+  Note that this mode is not 100% reliable, which is why --min-users-aggregate is set to 2 by default,
+  i.e. any song that is shared by only one peer will be ignored. Enable --relax-filtering to
+  make the file filtering less aggressive.
+
+### Album Aggregate
+  Activated when --album and --aggregate are enabled, in this mode sldl searches for the query
+  and groups results into distinct albums. Two folders are considered same if they have the
+  same number of audio files, and the durations of the files are within --length-tol of each
+  other (or within 3 seconds if length-tol is not configured). If both folders have exactly one
+  audio file with similar lengths, also checks if the inferred title and artist name coincide.
+  More reliable than normal aggregate due to much simpler grouping logic.  
+  Note that --min-users-aggregate is 2 by default, which means that folders shared by only one
+  peer are ignored.
+
+
+## Searching
+
+### Soulseek's rate limits
+  The server will ban you for 30 minutes if too many searches are performed within a short
+  timespan. The program has a search limiter which can be adjusted with --searches-per-time
+  and --searches-renew-time (when the limit is reached, the status of the downloads will be
+  "Waiting"). By default it is configured to allow up to 34 searches every 220 seconds.
+  The default values were determined through experimentation, so they may be incorrect.
+
+### Quality vs Speed
+  The following options will make it go faster, but may decrease search result quality or cause
+  instability:
+  - --fast-search skips waiting until the search completes and downloads as soon as a file
+    matching the preferred conditions is found
+  - --concurrent-downloads - set it to 4 or more
+  - --max-stale-time is set to 50 seconds by default, so it will wait a long time before giving
+    up on a file
+  - --searches-per-time increase at the risk of bans.
+
+### Quality vs Quantity
+  The options --strict-title, --strict-artist and --strict-album will filter any file that
+  does not contain the title/artist/album in the filename (ignoring case, bounded by boundary
+  chars).  
+  Another way to prevent false downloads is to set --length-tol to 3 or less to make it ignore
+  any songs that differ from the input by more than 3 seconds. However, all 4 options are already
+  enabled as 'preferred' conditions by default, meaning that such files will only be downloaded
+  as a last resort anyways. Hence it is only recommended to enable them if you need to minimize
+  false downloads as much as possible.
+
+
+## File conditions
+
+Files not satisfying the required conditions will not be downloaded. Files satisfying pref-
+conditions will be preferred; setting --pref-format "flac,wav" will make it download lossless
+files if available, and only download lossy files if there's nothing else.
+
+There are no default required conditions. The default preferred conditions are:
+```
+format = mp3
+length-tol = 3
+min-bitrate = 200
+max-bitrate = 2500
+max-samplerate = 48000
+strict-title = true
+strict-album = true
+accept-no-length = false
+```
+sldl will therefore prefer mp3 files with bitrate between 200 and 2500 kbps, and whose length
+differs from the supplied length by no more than 3 seconds. It will also prefer files whose
+paths contain the supplied artist and album (ignoring case, and bounded by boundary characters)
+and which have a non-null length. Changing the last three preferred conditions is not recommended.
+
+### Important note
+  Some info may be unavailable depending on the client used by the peer. For example, the standard
+  Soulseek client does not share the file bitrate. If (e.g) --min-bitrate is set, then sldl will
+  still accept any file with unknown bitrate. You can configure it to reject all files where one
+  or more of the checked properties is null (unknown) by enabling --strict-conditions.  
+  As a consequence, if --min-bitrate is also set then any files shared by users with the default
+  client will be ignored. Also note that the default preferred conditions will already affect
+  ranking with this option due to the bitrate and samplerate checks.
+
+Conditions can also be supplied as a semicolon-delimited string with --cond and --pref, e.g
+--cond "br>=320;f=mp3,ogg;sr<96000"
+
+
+## Name format
+
+Variables enclosed in {} will be replaced by the corresponding file tag value.
+Name format supports subdirectories as well as conditional expressions like {tag1|tag2} - If
+tag1 is null, use tag2. String literals enclosed in parentheses are ignored in the null check.
+
+### Examples:
+  - "{artist} - {title}"
+      Always name it 'Artist - Title'. Because some files on Soulseek are untagged, the
+      following is generally preferred:
+  - "{artist( - )title|filename}"
+      If artist and title are not null, name it 'Artist - Title', otherwise use the original
+      filename.
+
+### Available variables:
+```
+artist                          First artist (from the file tags)
+sartist                         Source artist (as on CSV/Spotify/YouTube/etc)
+artists                         Artists, joined with '&'
+albumartist                     First album artist
+albumartists                    Album artists, joined with '&'
+title                           Track title
+stitle                          Source track title
+album                           Album name
+salbum                          Source album name
+year                            Track year or date
+track                           Track number
+disc                            Disc number
+filename                        Soulseek filename without extension
+foldername                      Default sldl folder name
+extractor                       Name of the extractor used (CSV/Spotify/YouTube/etc)
+```
+
+## Skip existing
+
+sldl can skip files that exist in the download directory or a specified directory configured with
+--music-dir.
+The following modes are available for --skip-mode:
+
+### m3u
+Default when checking in the output directory.  
+  Checks whether the output m3u file contains the track in the '#SLDL' line. Does not check if
+  the audio file exists or satisfies the file conditions (use m3u-cond for that).
+
+### name
+  Compares filenames to the track title and artist name to determine if a track already exists.
+  Specifically, a track will be skipped if there exists a file whose name contains the title
+  and whose full path contains the artist name.
+
+### tag
+  Compares file tags to the track title and artist name. A track is skipped if there is a file
+  whose artist tag contains the track artist and whose title tag equals the track title
+  (ignoring case and ws). Slower than name mode as it needs to read all file tags.
+
+### m3u-cond, name-cond, tag-cond
+Default for checking in --music-dir: name-cond.  
+  Same as the above modes but also checks whether the found file satisfies necessary conditions.
+  Equivalent to the above modes if no necessary conditions have been specified (except m3u-cond
+  which always checks if the file exists). May be slower and use a lot of memory for large
+  libraries.
+
+## Configuration
+### Config Location:
+  sldl will look for a file named sldl.conf in the following locations:
+```
+~/AppData/Roaming/sldl/sldl.conf
+~/.config/sldl/sldl.conf
+```
+  as well as in the directory of the executable.
+
+### Syntax:
+  Example config file:
+```
+username = your-username
+password = your-password
+pref-format = flac
+fast-search = true
+```
+  Lines starting with hashtags (#) will be ignored. Tildes in paths are expanded as the user
+  directory.
+
+### Configuration profiles:
+  Profiles are supported:
+```
+[lossless]
+pref-format = flac,wav
+```
+  To activate the above profile, run --profile "lossless". To list all available profiles,
+  run --profile "help".  
+  Profiles can be activated automatically based on a few simple conditions:
+```
+[no-stale]
+profile-cond = interactive && download-mode == "album"
+max-stale-time = 999999
+# album downloads will never be automatically cancelled in interactive mode
+
+[youtube]
+profile-cond = input-type == "youtube"
+path = ~/downloads/sldl-youtube
+# download to another location for youtube
+```
+  The following operators are supported: &&, ||, ==, !=, ! (negation for bools).  
+  The following variables are available for use in profile-cond:
+```
+input-type        ( = "youtube"|"csv"|"string"|"bandcamp"|"spotify")
+download-mode     ( = "normal"|"aggregate"|"album"|"album-aggregate")
+interactive       (bool)
+  ```
 ## Examples
 
 Download tracks from a csv file:
 ```
 sldl test.csv
 ```
-<details>
-  <summary>CSV details</summary>
-  
-The names of the columns in the csv should be: `Artist`, `Title`, `Album`, `Length`. Some alternatives are also accepted. You can use `--print tracks` before downloading to check if everything has been parsed correctly. Only the title or album column is required, but additional info may improve search results.  
-
-</details> 
-
 <br>
 
 Download spotify likes while skipping songs that already exist in the output folder:
 ```
 sldl spotify-likes --skip-existing
 ```
-<details>
-  <summary>Spotify details</summary>
-
-To download private playlists or liked songs you will need to provide a client id and secret, which you can get here https://developer.spotify.com/dashboard/applications. Create an app and add `http://localhost:48721/callback` as a redirect url in its settings.  
-
-</details> 
-
 <br>
 
 Download from a youtube playlist with fallback to yt-dlp in case it is not found on soulseek, and retrieve deleted video titles from wayback machine:
 ```
 sldl "https://www.youtube.com/playlist?list=PLI_eFW8NAFzYAXZ5DrU6E6mQ_XfhaLBUX" --get-deleted --yt-dlp
 ```
-<details>
-  <summary>YouTube details</summary>
-
-Playlists are retrieved using the YoutubeExplode library which unfortunately doesn't always return all videos. You can use the official API by providing a key with `--youtube-key`. Get it here https://console.cloud.google.com. Create a new project, click "Enable Api" and search for "youtube data", then follow the prompts.
-Also note that due the high number of music videos in the above example playlist, it may be better to remove all text in parentheses and disable song duration checking: `--regex "[\[\(].*?[\]\)]" --pref-length-tol -1`.
-
-</details> 
-
 <br>
 
 Search & download a specific song, preferring lossless:
 ```
 sldl "title=MC MENTAL @ HIS BEST,length=242" --pref-format "flac,wav"
 ```  
-<details>
-  <summary>String details</summary>
-
-  The shorthand `sldl "Artist - Title"` is equivalent to `sldl "artist=Artist,title=Title"`.
-
-</details> 
-
 <br>
 
 Interactive album download:
 ```
 sldl "album=Some Album" --interactive
 ```
-<details>
-  <summary>Album details</summary>
-
-  The shorthand `sldl "Artist - Album" -a` is equivalent to `sldl "artist=Artist,album=Album"`. It's often helpful to restrict to folders which have two or more tracks: `--atc 2+`.
-
-</details> 
-  
 <br>
 
 Print all songs by an artist which are not in your library:
 ```
 sldl "artist=MC MENTAL" --aggregate --skip-existing --music-dir "path/to/music" --print tracks-full
 ```
+<br>
 
-## Download Modes
-
-Depending on the provided input, the download behaviour changes:
-
-- Normal download: The program will download a single file for every input entry.
-- Album download: The program will search for the album and download an entire folder including non-audio files. Activated when the input is a link to a spotify or bandcamp album, when the input string or csv row has no track title, or when `-a`/`--album` is enabled.
-- Aggregate download: With `-g`/`--aggregate`, the program will first perform an ordinary search for the input, then attempt to group the results into distinct songs and download one of each kind. This can be used to download an artist's entire discography (or simply printing it, like in the example above), finding remixes of a song, etc. Note that it is not 100% reliable, which is why `--min-users-aggregate` is set to 2 by default, i.e. any song that is shared by only one person will be ignored. Enable `--relax-filtering` to make the file filtering less aggressive.
-
-## Options
-
-Acronyms of two- and --three-word-arguments are also accepted, e.g. --twa
+Download all albums:
 ```
-Usage: sldl <input> [OPTIONS]
-
-  <input>                        <input> is one of the following:
-
-                                 Spotify playlist url or 'spotify-likes': Download a spotify
-                                 playlist or your liked songs. --spotify-id and
-                                 --spotify-secret may be required in addition.
-
-                                 Youtube playlist url: Download songs from a youtube playlist.
-                                 Provide a --youtube-key to include unavailabe uploads.
-
-                                 Path to a local CSV file: Use a csv file containing track
-                                 info to download. The names of the columns should be Artist,
-                                 Title, Album, Length. Only the title or album column is
-                                 required, but extra info may improve search results.
-
-                                 Name of the track, album, or artist to search for:
-                                 Can either be any typical search string or a comma-separated
-                                 list like 'title=Song Name,artist=Artist Name,length=215'
-                                 Allowed properties are: title, artist, album, length (sec)
-                                 Specify artist and album only to download an album.
-
-Options:
-  --user <username>              Soulseek username
-  --pass <password>              Soulseek password
-
-  -p --path <path>               Download directory
-  -f --folder <name>             Subfolder name. Set to '.' to output directly to the
-                                 download folder (default: playlist/csv name)
-  -n --number <maxtracks>        Download the first n tracks of a playlist
-  -o --offset <offset>           Skip a specified number of tracks
-  -r --reverse                   Download tracks in reverse order
-  --name-format <format>         Name format for downloaded tracks, e.g "{artist} - {title}"
-  --fast-search                  Begin downloading as soon as a file satisfying the preferred
-                                 conditions is found. Higher chance to download wrong files.
-  --remove-from-source           Remove downloaded tracks from source playlist or CSV file
-                                 (spotify and CSV only)
-  --m3u <option>                 Create an m3u8 playlist file
-                                 'none': Do not create a playlist file
-                                 'fails' (default): Write only failed downloads to the m3u
-                                 'all': Write successes + fails as comments
-
-  --spotify-id <id>              spotify client ID
-  --spotify-secret <secret>      spotify client secret
-
-  --youtube-key <key>            Youtube data API key
-  --get-deleted                  Attempt to retrieve titles of deleted videos from wayback
-                                 machine. Requires yt-dlp.
-  --deleted-only                 Only retrieve & download deleted music. Combine with --print
-                                 tracks-full to display a list of all deleted titles & urls.
-
-  --time-format <format>         Time format in Length column of the csv file (e.g h:m:s.ms
-                                 for durations like 1:04:35.123). Default: s
-  --yt-parse                     Enable if the csv file contains YouTube video titles and
-                                 channel names; attempt to parse them into title and artist
-                                 names.
-
-  --format <format>              Accepted file format(s), comma-separated
-  --length-tol <sec>             Length tolerance in seconds
-  --min-bitrate <rate>           Minimum file bitrate
-  --max-bitrate <rate>           Maximum file bitrate
-  --min-samplerate <rate>        Minimum file sample rate
-  --max-samplerate <rate>        Maximum file sample rate
-  --min-bitdepth <depth>         Minimum bit depth
-  --max-bitdepth <depth>         Maximum bit depth
-  --banned-users <list>          Comma-separated list of users to ignore
-
-  --pref-format <format>         Preferred file format(s), comma-separated (default: mp3)
-  --pref-length-tol <sec>        Preferred length tolerance in seconds (default: 3)
-  --pref-min-bitrate <rate>      Preferred minimum bitrate (default: 200)
-  --pref-max-bitrate <rate>      Preferred maximum bitrate (default: 2500)
-  --pref-min-samplerate <rate>   Preferred minimum sample rate
-  --pref-max-samplerate <rate>   Preferred maximum sample rate (default: 48000)
-  --pref-min-bitdepth <depth>    Preferred minimum bit depth
-  --pref-max-bitdepth <depth>    Preferred maximum bit depth
-  --pref-banned-users <list>     Comma-separated list of users to deprioritize
-
-  --strict-conditions            Skip files with missing properties instead of accepting by
-                                 default; if --min-bitrate is set, ignores any files with
-                                 unknown bitrate.
-
-  -a --album                     Album download mode
-  -t --interactive               When downloading albums: Allows to select the wanted album
-  --album-track-count <num>      Specify the exact number of tracks in the album. Folders
-                                 with a different number of tracks will be ignored. Append
-                                 a '+' or '-' after the number for the inequalities >= and <=
-  --album-ignore-fails           When downloading an album and one of the files fails, do not
-                                 skip to the next source and do not delete all successfully
-                                 downloaded files
-  --album-art <option>           Retrieve additional images after downloading the album:
-                                 'largest': Download from the folder with the largest image
-                                 'most': Download from the folder containing the most images
-  --album-art-only               Only download album art for the provided album
-
-  -g --aggregate                 Instead of downloading a single track matching the input,
-                                 find and download all distinct songs associated with the
-                                 provided artist, album, or track title.
-  --min-users-aggregate <num>    Minimum number of users sharing a track before it is
-                                 downloaded in aggregate mode. Setting it to higher values
-                                 will significantly reduce false positives, but also cause it
-                                 to ignore rarer songs. Default: 2
-  --relax-filtering              Slightly relax file filtering in aggregate mode to include
-                                 more results
-
-  -s --skip-existing             Skip if a track matching file conditions is found in the
-                                 output folder or your music library (if provided)
-  --skip-mode <mode>             'name': Use only filenames to check if a track exists
-                                 'name-precise' (default): Use filenames and check conditions
-                                 'tag': Use file tags (slower)
-                                 'tag-precise': Use file tags and check file conditions
-                                 'm3u': Skip all tracks that don't have a fail entry in m3u
-  --music-dir <path>             Specify to also skip downloading tracks found in a music
-                                 library. Use with --skip-existing
-  --skip-not-found               Skip searching for tracks that weren't found on Soulseek
-                                 during the last run. Fails are read from the m3u file.
-
-  --no-remove-special-chars      Do not remove special characters before searching
-  --remove-ft                    Remove 'feat.' and everything after before searching
-  --remove-brackets              Remove square brackets and their contents before searching
-  --regex <regex>                Remove a regexp from all track titles and artist names.
-                                 Optionally specify a replacement regex after a semicolon.
-                                 Add 'T:', 'A:' or 'L:' at the start to only apply this to
-                                 the track title, artist, or album respectively.
-  --artist-maybe-wrong           Performs an additional search without the artist name.
-                                 Useful for sources like SoundCloud where the "artist"
-                                 could just be an uploader. Note that when downloading a
-                                 YouTube playlist via url, this option is set automatically
-                                 on a per-track basis, so it is best kept off in that case.
-  -d --desperate                 Tries harder to find the desired track by searching for the
-                                 artist/album/title only, then filtering. (slower search)
-  --yt-dlp                       Use yt-dlp to download tracks that weren't found on
-                                 Soulseek. yt-dlp must be available from the command line.
-  --yt-dlp-argument <str>        The command line arguments when running yt-dlp. Default:
-                                 "{id}" -f bestaudio/best -cix -o "{savepath}.%(ext)s"
-                                 Available vars are: {id}, {savedir}, {savepath} (w/o ext).
-                                 Note that with -x, yt-dlp will download webms in case
-                                 ffmpeg is unavailable.
-
-  -c --config <path>             Set config file location
-  --search-timeout <ms>          Max search time in ms (default: 5000)
-  --max-stale-time <ms>          Max download time without progress in ms (default: 50000)
-  --concurrent-downloads <num>   Max concurrent downloads (default: 2)
-  --searches-per-time <num>      Max searches per time interval. Higher values may cause
-                                 30-minute bans. (default: 34)
-  --searches-renew-time <sec>    Controls how often available searches are replenished.
-                                 Lower values may cause 30-minute bans. (default: 220)
-  --display-mode <option>        Changes how searches and downloads are displayed:
-                                 'single' (default): Show transfer state and percentage
-                                 'double': Transfer state and a large progress bar
-                                 'simple': No download bars or changing percentages
-  --listen-port <port>           Port for incoming connections (default: 50000)
-
-  --print <option>               Print tracks or search results instead of downloading:
-                                 'tracks': Print all tracks to be downloaded
-                                 'tracks-full': Print extended information about all tracks
-                                 'results': Print search results satisfying file conditions
-                                 'results-full': Print search results including full paths
-  --debug                        Print extra debug info
+sldl "artist=MC MENTAL" --aggregate --album
 ```
 
-### File conditions
-Files not satisfying the conditions will not be downloaded. Files satisfying `pref-` conditions will be preferred; setting `--pref-format "flac,wav"` will make it download high quality files if they exist, and only download low quality files if there's nothing else. Conditions can also be supplied as a semicolon-delimited string to `--cond` and `--pref`, e.g `--cond "br>=320;f=mp3,ogg;sr<96000"`. See the start of `Program.cs` for the default file conditions.
-
-**Important note**: Some info may be unavailable depending on the client used by the peer. For example, the default Soulseek client does not share the file bitrate. By default, if `--min-bitrate` is set, then files with unknown bitrate will still be downloaded. You can configure it to reject all files where one of the checked properties is unavailable by enabling `--strict-conditions`. (As a consequence, if `--min-bitrate` is also set then any files shared by users with the default client will be ignored)
-
-### Name format
-Variables enclosed in {} will be replaced by the corresponding file tag value. Available variables are: artist, sartist, artists, albumartist, albumartists, title, stitle, album, salbum, year, track, disc, filename, foldername. The variables sartist, stitle and salbum will be replaced by the source artist, title and album respectively (i.e what is shown in spotify/youtube/csv file) instead of the tag values of the downloaded file. Name format supports subdirectories as well as conditional expressions like `{tag1|tag2}` – If tag1 is null, choose tag2. String literals enclosed in parentheses are ignored in the null check. Examples:
-- `{artist} - {title}`: Always name it 'Artist - Title'. Because some files on Soulseek do not have tags, the second example is preferred:
-- `{artist( - )title|filename}`: If artist and title is not null, name it 'Artist - Title', otherwise use the original filename.
-
-### Quality vs Speed
-The following options will make it go faster, but may decrease search result quality or cause instability:
-- `--fast-search` skips waiting until the search completes and downloads as soon as a file matching the preferred conditions is found
-- `--concurrent-downloads` -  set it to 4 or more
-- `--max-stale-time` is set to 50 seconds by default, so it will wait a long time before giving up on a file
-- `--searches-per-time` increase at the risk of ban, see the notes section for details.
-
-### Quality vs Quantity
-The options `--strict-title`, `--strict-artist` and `--strict-album` will filter any file that does not contain the title/artist/album in the filename (ignoring case, bounded by boundary chars). Another way to prevent false downloads is to set `--length-tol` to 3 or less to make it ignore any songs that differ from the input by more than 3 seconds. However, all 4 options are already enabled as 'preferred' conditions by default, meaning that such files will only be downloaded as a last resort even without enabling these. Hence it is only recommended to enable them if you need to minimize false downloads as much as possible.
-
-## Configuration  
-Create a file named `sldl.conf` in the same directory as the executable and write your arguments there, e.g:
-```
-username = fakename
-password = fakepass
-pref-format = flac
-fast-search = true
-```  
-  
 ## Notes
 - For macOS builds you can use publish.sh to build the app. Download dotnet from https://dotnet.microsoft.com/en-us/download/dotnet/6.0, then run `chmod +x publish.sh && sh publish.sh`. For intel macs, uncomment the x64 and comment the arm64 section in publish.sh. 
 - `--display single` and especially `double` can cause the printed lines to be duplicated or overwritten on some configurations. Use `simple` if that's an issue.
-- The server will ban you for 30 minutes if too many searches are performed within a short timespan. The program has a search limiter which can be adjusted with `--searches-per-time` and `--searches-renew-time` (when limit is reached, the status of the downloads will be "Waiting"). By default it is configured to allow up to 34 searches every 220 seconds. These values were determined through experimentation as unfortunately I couldn't find any information regarding soulseek's rate limits, so they may be incorrect.
diff --git a/publish.bat b/publish.bat
index 38848f8..d852d08 100644
--- a/publish.bat
+++ b/publish.bat
@@ -1,6 +1,8 @@
 @echo off
 setlocal
 
+set DOTNET_CLI_TELEMETRY_OPTOUT=1
+
 if not exist slsk-batchdl\bin\zips mkdir slsk-batchdl\bin\zips
  
 REM win-x86
diff --git a/slsk-batchdl/Config.cs b/slsk-batchdl/Config.cs
new file mode 100644
index 0000000..1461641
--- /dev/null
+++ b/slsk-batchdl/Config.cs
@@ -0,0 +1,1167 @@
+
+using Enums;
+using Data;
+using System.Text;
+using System.Text.RegularExpressions;
+
+
+static class Config
+{
+    public static FileConditions necessaryCond = new();
+
+    public static FileConditions preferredCond = new()
+    {
+        Formats = new string[] { "mp3" },
+        LengthTolerance = 3,
+        MinBitrate = 200,
+        MaxBitrate = 2500,
+        MaxSampleRate = 48000,
+        StrictTitle = true,
+        StrictAlbum = true,
+        AcceptNoLength = false,
+    };
+
+    public static string parentFolder = Directory.GetCurrentDirectory();
+    public static string input = "";
+    public static string outputFolder = "";
+    public static string m3uFilePath = "";
+    public static string musicDir = "";
+    public static string folderName = "";
+    public static string defaultFolderName = "";
+    public static string spotifyId = "";
+    public static string spotifySecret = "";
+    public static string ytKey = "";
+    public static string username = "";
+    public static string password = "";
+    public static string artistCol = "";
+    public static string albumCol = "";
+    public static string trackCol = "";
+    public static string ytIdCol = "";
+    public static string descCol = "";
+    public static string trackCountCol = "";
+    public static string lengthCol = "";
+    public static string timeUnit = "s";
+    public static string nameFormat = "";
+    public static string invalidReplaceStr = " ";
+    public static string ytdlpArgument = "";
+    public static string onComplete = "";
+    public static string confPath = "";
+    public static string profile = "";
+    public static bool aggregate = false;
+    public static bool album = false;
+    public static bool albumArtOnly = false;
+    public static bool interactiveMode = false;
+    public static bool albumIgnoreFails = false;
+    public static bool setAlbumMinTrackCount = true;
+    public static bool setAlbumMaxTrackCount = false;
+    public static bool skipNotFound = false;
+    public static bool desperateSearch = false;
+    public static bool noRemoveSpecialChars = false;
+    public static bool artistMaybeWrong = false;
+    public static bool fastSearch = false;
+    public static bool ytParse = false;
+    public static bool removeFt = false;
+    public static bool removeBrackets = false;
+    public static bool reverse = false;
+    public static bool useYtdlp = false;
+    public static bool skipExisting = false;
+    public static bool removeTracksFromSource = false;
+    public static bool getDeleted = false;
+    public static bool deletedOnly = false;
+    public static bool removeSingleCharacterSearchTerms = false;
+    public static bool relax = false;
+    public static bool debugInfo = false;
+    public static bool noModifyShareCount = false;
+    public static bool useRandomLogin = false;
+    public static bool noBrowseFolder = false;
+    public static int downrankOn = -1;
+    public static int ignoreOn = -2;
+    public static int minAlbumTrackCount = -1;
+    public static int maxAlbumTrackCount = -1;
+    public static int fastSearchDelay = 300;
+    public static int maxTracks = int.MaxValue;
+    public static int minUsersAggregate = 2;
+    public static int offset = 0;
+    public static int maxStaleTime = 50000;
+    public static int updateDelay = 100;
+    public static int searchTimeout = 6000;
+    public static int concurrentProcesses = 2;
+    public static int unknownErrorRetries = 2;
+    public static int maxRetriesPerTrack = 30;
+    public static int listenPort = 49998;
+    public static int searchesPerTime = 34;
+    public static int searchRenewTime = 220;
+    public static double fastSearchMinUpSpeed = 1.0;
+    public static Track regexToReplace = new();
+    public static Track regexReplaceBy = new();
+    public static AlbumArtOption albumArtOption = AlbumArtOption.Default;
+    public static M3uOption m3uOption = M3uOption.Index;
+    public static DisplayMode displayMode = DisplayMode.Single;
+    public static InputType inputType = InputType.None;
+    public static SkipMode skipMode = SkipMode.M3uCond;
+    public static SkipMode skipModeMusicDir = SkipMode.NameCond;
+    public static PrintOption printOption = PrintOption.None;
+
+    static readonly Dictionary<string, (List<string> args, string? cond)> profiles = new();
+    static readonly HashSet<string> appliedProfiles = new();
+    static bool hasConfiguredM3uMode = false;
+    static bool confPathChanged = false;
+    static string[] arguments;
+
+    public static bool HasAutoProfiles { get; private set; } = false;
+    public static bool DoNotDownload => (printOption & (PrintOption.Results | PrintOption.Tracks)) != 0;
+    public static bool PrintTracks => (printOption & PrintOption.Tracks) != 0;
+    public static bool PrintResults => (printOption & PrintOption.Results) != 0;
+    public static bool PrintTracksFull => (printOption & PrintOption.Tracks) != 0 && (printOption & PrintOption.Full) != 0;
+    public static bool PrintResultsFull => (printOption & PrintOption.Results) != 0 && (printOption & PrintOption.Full) != 0;
+
+
+    public static bool ParseArgsAndReadConfig(string[] args)
+    {
+        args = args.SelectMany(arg =>
+        {
+            if (arg.Length > 3 && arg.StartsWith("--") && arg.Contains('='))
+            {
+                var parts = arg.Split('=', 2);
+                return new[] { parts[0], parts[1] };
+            }
+            return new[] { arg };
+        }).ToArray();
+
+        SetConfigPath(args);
+
+        if (confPath != "none" && (confPathChanged || File.Exists(confPath)))
+        {
+            if (File.Exists(Path.Join(AppDomain.CurrentDomain.BaseDirectory, confPath)))
+                confPath = Path.Join(AppDomain.CurrentDomain.BaseDirectory, confPath);
+            ParseConfig(confPath);
+        }
+
+        args = args.SelectMany(arg =>
+        {
+            if (arg.Length > 2 && arg[0] == '-' && arg[1] != '-' && !arg.Contains(' '))
+                return arg[1..].Select(c => $"-{c}");
+            return new[] { arg };
+        }).ToArray();
+
+        arguments = args;
+
+        int profileIndex = Array.FindLastIndex(args, x => x == "--profile");
+
+        if (profileIndex != -1 && profileIndex < args.Length - 1)
+        {
+            profile = args[profileIndex + 1];
+            if (profile == "help")
+            {
+                ListProfiles();
+                return false;
+            }
+        }
+
+        if (profiles.ContainsKey("default"))
+        {
+            ProcessArgs(profiles["default"].args);
+            appliedProfiles.Add("default");
+        }
+
+        if (HasAutoProfiles)
+        {
+            ProcessArgs(args);
+            ApplyAutoProfiles();
+        }
+
+        ApplyProfile(profile);
+
+        ProcessArgs(args);
+
+        return true;
+    }
+
+
+    static void SetConfigPath(string[] args)
+    {
+        int idx = Array.LastIndexOf(args, "-c");
+        int idx2 = Array.LastIndexOf(args, "--config");
+        idx = idx > idx2 ? idx : idx2;
+        if (idx != -1)
+        {
+            confPath = Utils.ExpandUser(args[idx + 1]);
+        }
+
+        if (confPath.Length > 0)
+        {
+            confPathChanged = true;
+        }
+
+        if (!confPathChanged)
+        {
+            var configPaths = new string[]
+            {
+                Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".config", "sldl", "sldl.conf"),
+                Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "sldl", "sldl.conf"),
+                Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "sldl.conf"),
+                Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "slsk-batchdl.conf"),
+            };
+
+            foreach (var path in configPaths)
+            {
+                if (File.Exists(path))
+                {
+                    confPath = path;
+                    break;
+                }
+            }
+        }
+    }
+
+
+    public static void PostProcessArgs() // must be run after Program.trackLists has been assigned
+    {
+        if (DoNotDownload || debugInfo)
+            concurrentProcesses = 1;
+
+        ignoreOn = Math.Min(ignoreOn, downrankOn);
+
+        if (DoNotDownload)
+            m3uOption = M3uOption.None;
+        else if (!hasConfiguredM3uMode && inputType == InputType.String)
+            m3uOption = M3uOption.None;
+        else if (!hasConfiguredM3uMode && !aggregate && Program.trackLists != null && Program.trackLists.Flattened(true, false, true).All(t => t.IsAlbum))
+            m3uOption = M3uOption.None;
+
+        parentFolder = Utils.ExpandUser(parentFolder);
+        m3uFilePath = Utils.ExpandUser(m3uFilePath);
+        musicDir = Utils.ExpandUser(musicDir);
+
+        if (folderName.Length == 0)
+            folderName = defaultFolderName;
+        if (folderName == ".")
+            folderName = "";
+
+        folderName = folderName.Replace("\\", "/");
+        folderName = string.Join('/', folderName.Split('/').Select(x => x.ReplaceInvalidChars(invalidReplaceStr).Trim()));
+        folderName = folderName.Replace('/', Path.DirectorySeparatorChar);
+
+        outputFolder = Path.Join(parentFolder, folderName);
+
+        if (m3uFilePath.Length == 0)
+            m3uFilePath = Path.Join(outputFolder, (folderName.Length == 0 ? "playlist" : folderName) + ".m3u8");
+    }
+
+
+    static void ParseConfig(string path)
+    {
+        var lines = File.ReadAllLines(path);
+        var curProfile = "default";
+
+        for (int i = 0; i < lines.Length; i++)
+        { 
+            string l = lines[i].Trim();
+            if (l.Length == 0 || l.StartsWith('#'))
+                continue;
+
+            if (l.StartsWith('[') && l.EndsWith(']'))
+            {
+                curProfile = l[1..^1];
+                continue;
+            }
+
+            int idx = l.IndexOf('=');
+            if (idx <= 0 || idx == l.Length - 1)
+                throw new ArgumentException($"Error parsing config '{path}' at line {i}");
+
+            var x = l.Split('=', 2, StringSplitOptions.TrimEntries);
+            string key = x[0];
+            string val = x[1];
+
+            if (val[0] == '"' && val[^1] == '"')
+                val = val[1..^1];
+
+            if (!profiles.ContainsKey(curProfile))
+                profiles[curProfile] = (new List<string>(), null);
+
+            if (key == "profile-cond" && curProfile != "default")
+            {
+                var a = profiles[curProfile].args;
+                profiles[curProfile] = (a, val);
+                HasAutoProfiles = true;
+            }
+            else
+            {
+                if (key.Length == 1)
+                    key = '-' + key;
+                else
+                    key = "--" + key;
+
+                profiles[curProfile].args.Add(key);
+                profiles[curProfile].args.Add(val);
+            }
+        }
+    }
+
+
+    public static void UpdateArgs(TrackListEntry tle)
+    {
+        if (DoNotDownload)
+            return;
+        if (!HasAutoProfiles)
+            return;
+
+        var newProfiles = ApplyAutoProfiles(tle);
+
+        if (newProfiles.Count > 0)
+        {
+            //appliedProfiles.Clear();
+            appliedProfiles.Union(newProfiles);
+            ApplyProfile(profile);
+            ProcessArgs(arguments);
+            PostProcessArgs();
+        }
+    }
+
+
+    static void ApplyProfile(string name)
+    {
+        if (name.Length > 0 && name != "default")
+        {
+            if (profiles.ContainsKey(name))
+            {
+                ProcessArgs(profiles[name].args);
+                appliedProfiles.Add(name);
+            }
+            else
+                Console.WriteLine($"Error: No profile '{name}' found in config");
+        }
+    }
+
+
+    static HashSet<string> ApplyAutoProfiles(TrackListEntry? tle = null)
+    {
+        var applied = new HashSet<string>();
+
+        if (!HasAutoProfiles)
+            return applied;
+
+        foreach ((var key, var val) in profiles)
+        {
+            if (key == "default" || appliedProfiles.Contains(key))
+                continue;
+            if (key != profile && val.cond != null && ProfileConditionSatisfied(val.cond, tle))
+            {
+                Console.WriteLine($"Applying auto profile: {key}");
+                ProcessArgs(val.args);
+                appliedProfiles.Add(key);
+                applied.Add(key);
+            }
+        }
+
+        return applied;
+    }
+
+
+    static object GetVarValue(string var, TrackListEntry? tle = null)
+    {
+        static string toKebab(string input)
+        {
+            return string.Concat(input.Select((x, i) 
+                => char.IsUpper(x) && i > 0 ? "-" + char.ToLower(x).ToString() : char.ToLower(x).ToString()));
+        }
+
+        return var switch
+        {
+            "input-type" => inputType.ToString().ToLower(),
+            "download-mode" => tle != null ? toKebab(tle.type.ToString())
+                : album && aggregate ? "album-aggregate" : album ? "album" : aggregate ? "aggregate" : "normal",
+            "interactive" => interactiveMode,
+            "album" => album,
+            "aggregate" => aggregate,
+            _ => throw new ArgumentException($"Unrecognized profile condition variable {var}")
+        };
+    }
+
+
+    public static bool ProfileConditionSatisfied(string cond, TrackListEntry? tle = null)
+    {
+        var tokens = new Queue<string>(Regex.Split(cond, @"(\s+|\(|\)|&&|\|\||==|!=|!|\"".*?\"")").Where(t => !string.IsNullOrWhiteSpace(t)));
+
+        bool ParseExpression()
+        {
+            var left = ParseAndExpression();
+
+            while (tokens.Count > 0)
+            {
+                string token = tokens.Peek();
+                if (token == "||")
+                {
+                    tokens.Dequeue();
+                    var right = ParseAndExpression();
+                    left = left || right;
+                }
+                else
+                    break;
+            }
+
+            return left;
+        }
+
+        bool ParseAndExpression()
+        {
+            var left = ParsePrimaryExpression();
+
+            while (tokens.Count > 0)
+            {
+                string token = tokens.Peek();
+                if (token == "&&")
+                {
+                    tokens.Dequeue();
+                    var right = ParsePrimaryExpression();
+                    left = left && right;
+                }
+                else
+                    break;
+            }
+
+            return left;
+        }
+
+        bool ParsePrimaryExpression()
+        {
+            string token = tokens.Dequeue();
+
+            if (token == "(")
+            {
+                var result = ParseExpression();
+                tokens.Dequeue();
+                return result;
+            }
+
+            if (token == "!")
+                return !ParsePrimaryExpression();
+
+            if (token.StartsWith("\""))
+                throw new ArgumentException("Invalid token at this position: " + token);
+
+            if (tokens.Count > 0 && (tokens.Peek() == "==" || tokens.Peek() == "!="))
+            {
+                string op = tokens.Dequeue();
+                string value = tokens.Dequeue().Trim('"').ToLower();
+                string varValue = GetVarValue(token, tle).ToString().ToLower();
+                return op == "==" ? varValue == value : varValue != value;
+            }
+
+            return (bool)GetVarValue(token, tle);
+        }
+
+        return ParseExpression();
+    }
+
+
+    static void ListProfiles()
+    {
+        Console.WriteLine("Available profiles:");
+        foreach ((var key, var val) in profiles)
+        {
+            if (key == "default")
+                continue;
+            Console.WriteLine($"  [{key}]");
+            if (val.cond != null)
+                Console.WriteLine($"    profile-cond = {val.cond}");
+            for (int i = 0; i < val.args.Count; i += 2)
+            {
+                Console.WriteLine($"    {val.args[i].TrimStart('-')} = {val.args[i + 1]}");
+            }
+            Console.WriteLine();
+        }
+    }
+
+
+    static void ParseConditions(FileConditions cond, string input)
+    {
+        static void UpdateMinMax(string value, string condition, ref int min, ref int max)
+        {
+            if (condition.Contains(">="))
+                min = int.Parse(value);
+            else if (condition.Contains("<="))
+                max = int.Parse(value);
+            else if (condition.Contains('>'))
+                min = int.Parse(value) + 1;
+            else if (condition.Contains('<'))
+                max = int.Parse(value) - 1;
+            else if (condition.Contains('='))
+                min = max = int.Parse(value);
+        }
+
+        var tr = StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries;
+        string[] conditions = input.Split(';', tr);
+        foreach (string condition in conditions)
+        {
+            string[] parts = condition.Split(new string[] { ">=", "<=", "=", ">", "<" }, 2, tr);
+            string field = parts[0].Replace("-", "").Trim().ToLower();
+            string value = parts.Length > 1 ? parts[1].Trim() : "true";
+
+            switch (field)
+            {
+                case "sr":
+                case "samplerate":
+                    UpdateMinMax(value, condition, ref cond.MinSampleRate, ref cond.MaxSampleRate);
+                    break;
+                case "br":
+                case "bitrate":
+                    UpdateMinMax(value, condition, ref cond.MinBitrate, ref cond.MaxBitrate);
+                    break;
+                case "bd":
+                case "bitdepth":
+                    UpdateMinMax(value, condition, ref cond.MinBitDepth, ref cond.MaxBitDepth);
+                    break;
+                case "t":
+                case "tol":
+                case "lentol":
+                case "lengthtol":
+                case "tolerance":
+                case "lengthtolerance":
+                    cond.LengthTolerance = int.Parse(value);
+                    break;
+                case "f":
+                case "format":
+                case "formats":
+                    cond.Formats = value.Split(',', tr);
+                    break;
+                case "banned":
+                case "bannedusers":
+                    cond.BannedUsers = value.Split(',', tr);
+                    break;
+                case "dangerwords":
+                    cond.DangerWords = value.Split(',', tr);
+                    break;
+                case "stricttitle":
+                    cond.StrictTitle = bool.Parse(value);
+                    break;
+                case "strictartist":
+                    cond.StrictArtist = bool.Parse(value);
+                    break;
+                case "strictalbum":
+                    cond.StrictAlbum = bool.Parse(value);
+                    break;
+                case "acceptnolen":
+                case "acceptnolength":
+                    cond.AcceptNoLength = bool.Parse(value);
+                    break;
+                case "strict":
+                case "acceptmissing":
+                case "acceptmissingprops":
+                    cond.AcceptMissingProps = bool.Parse(value);
+                    break;
+                default:
+                    throw new ArgumentException($"Unknown condition '{condition}'");
+            }
+        }
+    }
+
+
+    static void ProcessArgs(IReadOnlyList<string> args)
+    {
+        void setFlag(ref bool flag, ref int i, bool trueVal = true)
+        {
+            if (i >= args.Count - 1 || args[i + 1].StartsWith('-'))
+                flag = trueVal;
+            else if (args[i + 1] == "false")
+            {
+                flag = !trueVal;
+                i++;
+            }
+            else if (args[i + 1] == "true")
+            {
+                flag = trueVal;
+                i++;
+            }
+            else
+                flag = trueVal;
+        }
+
+        bool inputSet = false;
+
+        for (int i = 0; i < args.Count; i++)
+        {
+            if (args[i].StartsWith("-"))
+            {
+                switch (args[i])
+                {
+                    case "-i":
+                    case "--input":
+                        input = args[++i];
+                        break;
+                    case "--it":
+                    case "--input-type":
+                        inputType = args[++i].ToLower().Trim() switch
+                        {
+                            "none" => InputType.None,
+                            "csv" => InputType.CSV,
+                            "youtube" => InputType.YouTube,
+                            "spotify" => InputType.Spotify,
+                            "bandcamp" => InputType.Bandcamp,
+                            "string" => InputType.String,
+                            _ => throw new ArgumentException($"Invalid input type '{args[i]}'"),
+                        };
+                        break;
+                    case "-p":
+                    case "--path":
+                        parentFolder = args[++i];
+                        break;
+                    case "-c":
+                    case "--config":
+                        confPath = args[++i];
+                        break;
+                    case "-f":
+                    case "--folder":
+                        folderName = args[++i];
+                        break;
+                    case "-m":
+                    case "--md":
+                    case "--music-dir":
+                        musicDir = args[++i];
+                        break;
+                    case "-g":
+                    case "--aggregate":
+                        setFlag(ref aggregate, ref i);
+                        break;
+                    case "--mua":
+                    case "--min-users-aggregate":
+                        minUsersAggregate = int.Parse(args[++i]);
+                        break;
+                    case "--rf":
+                    case "--relax":
+                    case "--relax-filtering":
+                        setFlag(ref relax, ref i);
+                        break;
+                    case "--si":
+                    case "--spotify-id":
+                        spotifyId = args[++i];
+                        break;
+                    case "--ss":
+                    case "--spotify-secret":
+                        spotifySecret = args[++i];
+                        break;
+                    case "--yk":
+                    case "--youtube-key":
+                        ytKey = args[++i];
+                        break;
+                    case "-l":
+                    case "--login":
+                        var login = args[++i].Split(';', 2);
+                        username = login[0];
+                        password = login[1];
+                        break;
+                    case "--user":
+                    case "--username":
+                        username = args[++i];
+                        break;
+                    case "--pass":
+                    case "--password":
+                        password = args[++i];
+                        break;
+                    case "--rl":
+                    case "--random-login":
+                        setFlag(ref useRandomLogin, ref i);
+                        break;
+                    case "--ac":
+                    case "--artist-col":
+                        artistCol = args[++i];
+                        break;
+                    case "--tc":
+                    case "--track-col":
+                        trackCol = args[++i];
+                        break;
+                    case "--alc":
+                    case "--album-col":
+                        albumCol = args[++i];
+                        break;
+                    case "--ydc":
+                    case "--yt-desc-col":
+                        descCol = args[++i];
+                        break;
+                    case "--atcc":
+                    case "--album-track-count-col":
+                        trackCountCol = args[++i];
+                        break;
+                    case "--yic":
+                    case "--yt-id-col":
+                        ytIdCol = args[++i];
+                        break;
+                    case "--lc":
+                    case "--length-col":
+                        lengthCol = args[++i];
+                        break;
+                    case "--tf":
+                    case "--time-format":
+                        timeUnit = args[++i];
+                        break;
+                    case "-n":
+                    case "--number":
+                        maxTracks = int.Parse(args[++i]);
+                        break;
+                    case "-o":
+                    case "--offset":
+                        offset = int.Parse(args[++i]);
+                        break;
+                    case "--nf":
+                    case "--name-format":
+                        nameFormat = args[++i];
+                        break;
+                    case "--irs":
+                    case "--invalid-replace-str":
+                        invalidReplaceStr = args[++i];
+                        break;
+                    case "--print":
+                        printOption = args[++i].ToLower().Trim() switch
+                        {
+                            "none" => PrintOption.None,
+                            "tracks" => PrintOption.Tracks,
+                            "results" => PrintOption.Results,
+                            "tracks-full" => PrintOption.Tracks | PrintOption.Full,
+                            "results-full" => PrintOption.Results | PrintOption.Full,
+                            _ => throw new ArgumentException($"Invalid print option '{args[i]}'"),
+                        };
+                        break;
+                    case "--pt":
+                    case "--print-tracks":
+                        printOption = PrintOption.Tracks;
+                        break;
+                    case "--ptf":
+                    case "--print-tracks-full":
+                        printOption = PrintOption.Tracks | PrintOption.Full;
+                        break;
+                    case "--pr":
+                    case "--print-results":
+                        printOption = PrintOption.Results;
+                        break;
+                    case "--prf":
+                    case "--print-results-full":
+                        printOption = PrintOption.Results | PrintOption.Full;
+                        break;
+                    case "--yp":
+                    case "--yt-parse":
+                        setFlag(ref ytParse, ref i);
+                        break;
+                    case "--yd":
+                    case "--yt-dlp":
+                        setFlag(ref useYtdlp, ref i);
+                        break;
+                    case "-s":
+                    case "--se":
+                    case "--skip-existing":
+                        setFlag(ref skipExisting, ref i);
+                        break;
+                    case "--snf":
+                    case "--skip-not-found":
+                        setFlag(ref skipNotFound, ref i);
+                        break;
+                    case "--rfp":
+                    case "--rfs":
+                    case "--remove-from-source":
+                    case "--remove-from-playlist":
+                        setFlag(ref removeTracksFromSource, ref i);
+                        break;
+                    case "--rft":
+                    case "--remove-ft":
+                        setFlag(ref removeFt, ref i);
+                        break;
+                    case "--rb":
+                    case "--remove-brackets":
+                        setFlag(ref removeBrackets, ref i);
+                        break;
+                    case "--gd":
+                    case "--get-deleted":
+                        setFlag(ref getDeleted, ref i);
+                        break;
+                    case "--do":
+                    case "--deleted-only":
+                        setFlag(ref getDeleted, ref i);
+                        setFlag(ref deletedOnly, ref i);
+                        break;
+                    case "--re":
+                    case "--regex":
+                        string s = args[++i].Replace("\\;", "<<semicol>>");
+                        string applyTo = "TAL";
+
+                        if (s.Length > 2 && s[1] == ':' && (s[0] == 'T' || s[0] == 'A' || s[0] == 'L'))
+                        {
+                            applyTo = s[0].ToString();
+                            s = s[2..];
+                        }
+
+                        var parts = s.Split(";").ToArray();
+                        string toReplace = parts[0].Replace("<<semicol>>", ";");
+                        string replaceBy = parts.Length > 1 ? parts[1].Replace("<<semicol>>", ";") : "";
+
+                        if (applyTo.Contains('T'))
+                        {
+                            regexToReplace.Title = toReplace;
+                            regexReplaceBy.Title = replaceBy;
+                        }
+                        if (applyTo.Contains('A'))
+                        {
+                            regexToReplace.Artist = toReplace;
+                            regexReplaceBy.Artist = replaceBy;
+                        }
+                        if (applyTo.Contains('L'))
+                        {
+                            regexToReplace.Album = toReplace;
+                            regexReplaceBy.Album = replaceBy;
+                        }
+                        break;
+                    case "-r":
+                    case "--reverse":
+                        setFlag(ref reverse, ref i);
+                        break;
+                    case "--m3u":
+                    case "--m3u8":
+                        hasConfiguredM3uMode = true;
+                        m3uOption = args[++i].ToLower().Trim() switch
+                        {
+                            "none" => M3uOption.None,
+                            "index" => M3uOption.Index,
+                            "all" => M3uOption.All,
+                            _ => throw new ArgumentException($"Invalid m3u option '{args[i]}'"),
+                        };
+                        break;
+                    case "--lp":
+                    case "--port":
+                    case "--listen-port":
+                        listenPort = int.Parse(args[++i]);
+                        break;
+                    case "--st":
+                    case "--timeout":
+                    case "--search-timeout":
+                        searchTimeout = int.Parse(args[++i]);
+                        break;
+                    case "--mst":
+                    case "--stale-time":
+                    case "--max-stale-time":
+                        maxStaleTime = int.Parse(args[++i]);
+                        break;
+                    case "--cp":
+                    case "--cd":
+                    case "--processes":
+                    case "--concurrent-processes":
+                    case "--concurrent-downloads":
+                        concurrentProcesses = int.Parse(args[++i]);
+                        break;
+                    case "--spt":
+                    case "--searches-per-time":
+                        searchesPerTime = int.Parse(args[++i]);
+                        break;
+                    case "--srt":
+                    case "--searches-renew-time":
+                        searchRenewTime = int.Parse(args[++i]);
+                        break;
+                    case "--mr":
+                    case "--retries":
+                    case "--max-retries":
+                        maxRetriesPerTrack = int.Parse(args[++i]);
+                        break;
+                    case "--atc":
+                    case "--album-track-count":
+                        string a = args[++i];
+                        if (a == "-1")
+                        {
+                            minAlbumTrackCount = -1;
+                            maxAlbumTrackCount = -1;
+                        }
+                        else if (a.Last() == '-')
+                        {
+                            maxAlbumTrackCount = int.Parse(a[..^1]);
+                        }
+                        else if (a.Last() == '+')
+                        {
+                            minAlbumTrackCount = int.Parse(a[..^1]);
+                        }
+                        else
+                        {
+                            minAlbumTrackCount = int.Parse(a);
+                            maxAlbumTrackCount = minAlbumTrackCount;
+                        }
+                        break;
+                    case "--matc":
+                    case "--min-album-track-count":
+                        minAlbumTrackCount = int.Parse(args[++i]);
+                        break;
+                    case "--Matc":
+                    case "--max-album-track-count":
+                        maxAlbumTrackCount = int.Parse(args[++i]);
+                        break;
+                    case "--eMtc":
+                    case "--extract-max-track-count":
+                        setFlag(ref setAlbumMaxTrackCount, ref i);
+                        break;
+                    case "--emtc":
+                    case "--extract-min-track-count":
+                        setFlag(ref setAlbumMinTrackCount, ref i);
+                        break;
+                    case "--aa":
+                    case "--album-art":
+                        albumArtOption = args[++i].ToLower().Trim() switch
+                        {
+                            "default" => AlbumArtOption.Default,
+                            "largest" => AlbumArtOption.Largest,
+                            "most" => AlbumArtOption.Most,
+                            "most-largest" => AlbumArtOption.MostLargest,
+                            _ => throw new ArgumentException($"Invalid album art download mode '{args[i]}'"),
+                        };
+                        break;
+                    case "--aao":
+                    case "--aa-only":
+                    case "--album-art-only":
+                        setFlag(ref albumArtOnly, ref i);
+                        if (albumArtOption == AlbumArtOption.Default)
+                            albumArtOption = AlbumArtOption.Largest;
+                        preferredCond = new FileConditions();
+                        necessaryCond = new FileConditions();
+                        break;
+                    case "--aif":
+                    case "--album-ignore-fails":
+                        setFlag(ref albumIgnoreFails, ref i);
+                        break;
+                    case "-t":
+                    case "--interactive":
+                        setFlag(ref interactiveMode, ref i);
+                        break;
+                    case "--pf":
+                    case "--paf":
+                    case "--pref-format":
+                        preferredCond.Formats = args[++i].Split(',', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries);
+                        break;
+                    case "--plt":
+                    case "--pref-tolerance":
+                    case "--pref-length-tol":
+                    case "--pref-length-tolerance":
+                        preferredCond.LengthTolerance = int.Parse(args[++i]);
+                        break;
+                    case "--pmbr":
+                    case "--pref-min-bitrate":
+                        preferredCond.MinBitrate = int.Parse(args[++i]);
+                        break;
+                    case "--pMbr":
+                    case "--pref-max-bitrate":
+                        preferredCond.MaxBitrate = int.Parse(args[++i]);
+                        break;
+                    case "--pmsr":
+                    case "--pref-min-samplerate":
+                        preferredCond.MinSampleRate = int.Parse(args[++i]);
+                        break;
+                    case "--pMsr":
+                    case "--pref-max-samplerate":
+                        preferredCond.MaxSampleRate = int.Parse(args[++i]);
+                        break;
+                    case "--pmbd":
+                    case "--pref-min-bitdepth":
+                        preferredCond.MinBitDepth = int.Parse(args[++i]);
+                        break;
+                    case "--pMbd":
+                    case "--pref-max-bitdepth":
+                        preferredCond.MaxBitDepth = int.Parse(args[++i]);
+                        break;
+                    case "--pdw":
+                    case "--pref-danger-words":
+                        preferredCond.DangerWords = args[++i].Split(',');
+                        break;
+                    case "--pst":
+                    case "--pstt":
+                    case "--pref-strict-title":
+                        setFlag(ref preferredCond.StrictTitle, ref i);
+                        break;
+                    case "--psa":
+                    case "--pref-strict-artist":
+                        setFlag(ref preferredCond.StrictArtist, ref i);
+                        break;
+                    case "--psal":
+                    case "--pref-strict-album":
+                        setFlag(ref preferredCond.StrictAlbum, ref i);
+                        break;
+                    case "--pbu":
+                    case "--pref-banned-users":
+                        preferredCond.BannedUsers = args[++i].Split(',');
+                        break;
+                    case "--af":
+                    case "--format":
+                        necessaryCond.Formats = args[++i].Split(',', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries);
+                        break;
+                    case "--lt":
+                    case "--tolerance":
+                    case "--length-tol":
+                    case "--length-tolerance":
+                        necessaryCond.LengthTolerance = int.Parse(args[++i]);
+                        break;
+                    case "--mbr":
+                    case "--min-bitrate":
+                        necessaryCond.MinBitrate = int.Parse(args[++i]);
+                        break;
+                    case "--Mbr":
+                    case "--max-bitrate":
+                        necessaryCond.MaxBitrate = int.Parse(args[++i]);
+                        break;
+                    case "--msr":
+                    case "--min-samplerate":
+                        necessaryCond.MinSampleRate = int.Parse(args[++i]);
+                        break;
+                    case "--Msr":
+                    case "--max-samplerate":
+                        necessaryCond.MaxSampleRate = int.Parse(args[++i]);
+                        break;
+                    case "--mbd":
+                    case "--min-bitdepth":
+                        necessaryCond.MinBitDepth = int.Parse(args[++i]);
+                        break;
+                    case "--Mbd":
+                    case "--max-bitdepth":
+                        necessaryCond.MaxBitDepth = int.Parse(args[++i]);
+                        break;
+                    case "--dw":
+                    case "--danger-words":
+                        necessaryCond.DangerWords = args[++i].Split(',');
+                        break;
+                    case "--stt":
+                    case "--strict-title":
+                        setFlag(ref necessaryCond.StrictTitle, ref i);
+                        break;
+                    case "--sa":
+                    case "--strict-artist":
+                        setFlag(ref necessaryCond.StrictArtist, ref i);
+                        break;
+                    case "--sal":
+                    case "--strict-album":
+                        setFlag(ref necessaryCond.StrictAlbum, ref i);
+                        break;
+                    case "--bu":
+                    case "--banned-users":
+                        necessaryCond.BannedUsers = args[++i].Split(',');
+                        break;
+                    case "--c":
+                    case "--cond":
+                    case "--conditions":
+                        ParseConditions(necessaryCond, args[++i]);
+                        break;
+                    case "--pc":
+                    case "--pref":
+                    case "--preferred-conditions":
+                        ParseConditions(preferredCond, args[++i]);
+                        break;
+                    case "--nmsc":
+                    case "--no-modify-share-count":
+                        setFlag(ref noModifyShareCount, ref i);
+                        break;
+                    case "-d":
+                    case "--desperate":
+                        setFlag(ref desperateSearch, ref i);
+                        break;
+                    case "--dm":
+                    case "--display":
+                    case "--display-mode":
+                        displayMode = args[++i].ToLower().Trim() switch
+                        {
+                            "single" => DisplayMode.Single,
+                            "double" => DisplayMode.Double,
+                            "simple" => DisplayMode.Simple,
+                            _ => throw new ArgumentException($"Invalid display mode '{args[i]}'"),
+                        };
+                        break;
+                    case "--sm":
+                    case "--skip-mode":
+                        skipMode = args[++i].ToLower().Trim() switch
+                        {
+                            "name" => SkipMode.Name,
+                            "name-cond" => SkipMode.NameCond,
+                            "tag" => SkipMode.Tag,
+                            "tag-cond" => SkipMode.TagCond,
+                            "m3u" => SkipMode.M3u,
+                            "m3u-cond" => SkipMode.M3uCond,
+                            _ => throw new ArgumentException($"Invalid skip mode '{args[i]}'"),
+                        };
+                        break;
+                    case "--smmd":
+                    case "--skip-mode-music-dir":
+                        skipModeMusicDir = args[++i].ToLower().Trim() switch
+                        {
+                            "name" => SkipMode.Name,
+                            "name-cond" => SkipMode.NameCond,
+                            "tag" => SkipMode.Tag,
+                            "tag-cond" => SkipMode.TagCond,
+                            _ => throw new ArgumentException($"Invalid music dir skip mode '{args[i]}'"),
+                        };
+                        break;
+                    case "--nrsc":
+                    case "--no-remove-special-chars":
+                        setFlag(ref noRemoveSpecialChars, ref i);
+                        break;
+                    case "--amw":
+                    case "--artist-maybe-wrong":
+                        setFlag(ref artistMaybeWrong, ref i);
+                        break;
+                    case "--fs":
+                    case "--fast-search":
+                        setFlag(ref fastSearch, ref i);
+                        break;
+                    case "--fsd":
+                    case "--fast-search-delay":
+                        fastSearchDelay = int.Parse(args[++i]);
+                        break;
+                    case "--fsmus":
+                    case "--fast-search-min-up-speed":
+                        fastSearchMinUpSpeed = double.Parse(args[++i]);
+                        break;
+                    case "--debug":
+                        setFlag(ref debugInfo, ref i);
+                        break;
+                    case "--sc":
+                    case "--strict":
+                    case "--strict-conditions":
+                        setFlag(ref preferredCond.AcceptMissingProps, ref i, false);
+                        setFlag(ref necessaryCond.AcceptMissingProps, ref i, false);
+                        break;
+                    case "--yda":
+                    case "--yt-dlp-argument":
+                        ytdlpArgument = args[++i];
+                        break;
+                    case "-a":
+                    case "--album":
+                        setFlag(ref album, ref i);
+                        break;
+                    case "--oc":
+                    case "--on-complete":
+                        onComplete = args[++i];
+                        break;
+                    case "--ftd":
+                    case "--fails-to-downrank":
+                        downrankOn = -int.Parse(args[++i]);
+                        break;
+                    case "--fti":
+                    case "--fails-to-ignore":
+                        ignoreOn = -int.Parse(args[++i]);
+                        break;
+                    case "--uer":
+                    case "--unknown-error-retries":
+                        unknownErrorRetries = int.Parse(args[++i]);
+                        break;
+                    case "--profile":
+                        profile = args[++i];
+                        break;
+                    case "--nbf":
+                    case "--no-browse-folder":
+                        setFlag(ref noBrowseFolder, ref i);
+                        break;
+                    default:
+                        throw new ArgumentException($"Unknown argument: {args[i]}");
+                }
+            }
+            else
+            {
+                if (!inputSet)
+                {
+                    input = args[i].Trim();
+                    inputSet = true;
+                }
+                else
+                    throw new ArgumentException($"Invalid argument \'{args[i]}\'. Input is already set to \'{input}\'");
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/slsk-batchdl/Data.cs b/slsk-batchdl/Data.cs
new file mode 100644
index 0000000..8c9cc7d
--- /dev/null
+++ b/slsk-batchdl/Data.cs
@@ -0,0 +1,324 @@
+using Enums;
+
+using SlDictionary = System.Collections.Concurrent.ConcurrentDictionary<string, (Soulseek.SearchResponse, Soulseek.File)>;
+
+namespace Data
+{
+    public class Track
+    {
+        public string Title = "";
+        public string Artist = "";
+        public string Album = "";
+        public string URI = "";
+        public int Length = -1;
+        public bool ArtistMaybeWrong = false;
+        public bool IsAlbum = false;
+        public int MinAlbumTrackCount = -1;
+        public int MaxAlbumTrackCount = -1;
+        public bool IsNotAudio = false;
+        public string DownloadPath = "";
+        public string Other = "";
+        public int CsvRow = -1;
+        public FailureReason FailureReason = FailureReason.None;
+        public TrackState State = TrackState.Initial;
+        public SlDictionary? Downloads = null;
+
+        public Track() { }
+
+        public Track(Track other)
+        {
+            Title = other.Title;
+            Artist = other.Artist;
+            Album = other.Album;
+            Length = other.Length;
+            URI = other.URI;
+            ArtistMaybeWrong = other.ArtistMaybeWrong;
+            Downloads = other.Downloads;
+            IsAlbum = other.IsAlbum;
+            IsNotAudio = other.IsNotAudio;
+            State = other.State;
+            FailureReason = other.FailureReason;
+            DownloadPath = other.DownloadPath;
+            Other = other.Other;
+            MinAlbumTrackCount = other.MinAlbumTrackCount;
+            MaxAlbumTrackCount = other.MaxAlbumTrackCount;
+            CsvRow = other.CsvRow;
+        }
+
+        public string ToKey()
+        {
+            return $"{Artist};{Album};{Title};{Length}";
+        }
+
+        public override string ToString()
+        {
+            return ToString(false);
+        }
+
+        public string ToString(bool noInfo = false)
+        {
+            if (IsNotAudio && Downloads != null && !Downloads.IsEmpty)
+                return $"{Utils.GetFileNameSlsk(Downloads.First().Value.Item2.Filename)}";
+
+            string str = Artist;
+            if (!IsAlbum && Title.Length == 0 && Downloads != null && !Downloads.IsEmpty)
+            {
+                str = $"{Utils.GetFileNameSlsk(Downloads.First().Value.Item2.Filename)}";
+            }
+            else if (Title.Length > 0 || Album.Length > 0)
+            {
+                if (str.Length > 0)
+                    str += " - ";
+                if (IsAlbum)
+                    str += Album;
+                else if (Title.Length > 0)
+                    str += Title;
+                if (!noInfo)
+                {
+                    if (Length > 0)
+                        str += $" ({Length}s)";
+                    if (IsAlbum)
+                        str += " (album)";
+                }
+            }
+            else if (!noInfo)
+            {
+                str += " (artist)";
+            }
+
+            return str;
+        }
+    }
+
+    public class TrackListEntry
+    {
+        public List<List<Track>> list;
+        public ListType type;
+        public Track source;
+        public bool needSearch;
+        public bool placeInSubdir;
+
+        public TrackListEntry(List<List<Track>> list, ListType type, Track source)
+        {
+            this.list = list;
+            this.type = type;
+            this.source = source;
+
+            needSearch = type != ListType.Normal;
+            placeInSubdir = false;
+        }
+
+        public TrackListEntry(List<List<Track>> list, ListType type, Track source, bool needSearch, bool placeInSubdir)
+        {
+            this.list = list;
+            this.type = type;
+            this.source = source;
+            this.needSearch = needSearch;
+            this.placeInSubdir = placeInSubdir;
+        }
+    }
+
+    public class TrackLists
+    {
+        public List<TrackListEntry> lists = new();
+
+        public TrackLists() { }
+
+        public TrackLists(List<(List<List<Track>> list, ListType type, Track source)> lists)
+        {
+            foreach (var (list, type, source) in lists)
+            {
+                var newList = new List<List<Track>>();
+                foreach (var innerList in list)
+                {
+                    var innerNewList = new List<Track>(innerList);
+                    newList.Add(innerNewList);
+                }
+                this.lists.Add(new TrackListEntry(newList, type, source));
+            }
+        }
+
+        public static TrackLists FromFlattened(IEnumerable<Track> flatList, bool aggregate, bool album)
+        {
+            var res = new TrackLists();
+            using var enumerator = flatList.GetEnumerator();
+
+            while (enumerator.MoveNext())
+            {
+                var track = enumerator.Current;
+
+                if (album && aggregate)
+                {
+                    res.AddEntry(ListType.AlbumAggregate, track);
+                }
+                else if (aggregate)
+                {
+                    res.AddEntry(ListType.Aggregate, track);
+                }
+                else if (album || track.IsAlbum)
+                {
+                    track.IsAlbum = true;
+                    res.AddEntry(ListType.Album, track);
+                }
+                else
+                {
+                    res.AddEntry(ListType.Normal);
+                    res.AddTrackToLast(track);
+
+                    bool hasNext;
+                    while (true)
+                    {
+                        hasNext = enumerator.MoveNext();
+                        if (!hasNext || enumerator.Current.IsAlbum)
+                            break;
+                        res.AddTrackToLast(enumerator.Current);
+                    }
+
+                    if (hasNext && enumerator.Current.IsAlbum)
+                        res.AddEntry(ListType.Album, track);
+                    else if (!hasNext)
+                        break;
+                }
+            }
+
+            return res;
+        }
+
+        public TrackListEntry this[int index]
+        {
+            get { return lists[index]; }
+            set { lists[index] = value; }
+        }
+
+        public void AddEntry(TrackListEntry tle)
+        {
+            lists.Add(tle);
+        }
+
+        public void AddEntry(List<List<Track>>? list, ListType? type = null, Track? source = null)
+        {
+            type ??= ListType.Normal;
+            source ??= new Track();
+            list ??= new List<List<Track>>();
+            lists.Add(new TrackListEntry(list, (ListType)type, source));
+        }
+
+        public void AddEntry(List<Track> tracks, ListType? type = null, Track? source = null)
+        {
+            var list = new List<List<Track>>() { tracks };
+            AddEntry(list, type, source);
+        }
+
+        public void AddEntry(Track track, ListType? type = null, Track? source = null)
+        {
+            var list = new List<List<Track>>() { new List<Track>() { track } };
+            AddEntry(list, type, source);
+        }
+
+        public void AddEntry(ListType? type = null, Track? source = null)
+        {
+            var list = new List<List<Track>>() { new List<Track>() };
+            AddEntry(list, type, source);
+        }
+
+        public void AddTrackToLast(Track track)
+        {
+            int i = lists.Count - 1;
+            int j = lists[i].list.Count - 1;
+            lists[i].list[j].Add(track);
+        }
+
+        public void Reverse()
+        {
+            lists.Reverse();
+            foreach (var tle in lists)
+            {
+                foreach (var ls in tle.list)
+                {
+                    ls.Reverse();
+                }
+            }
+        }
+
+        public IEnumerable<Track> Flattened(bool addSources, bool addSpecialSourceTracks, bool sourcesOnly = false)
+        {
+            foreach (var tle in lists)
+            {
+                if ((addSources || sourcesOnly) && tle.source != null)
+                    yield return tle.source;
+                if (!sourcesOnly && tle.list.Count > 0 && (tle.type == ListType.Normal || addSpecialSourceTracks))
+                {
+                    foreach (var t in tle.list[0])
+                        yield return t;
+                }
+            }
+        }
+    }
+
+    public class TrackStringComparer : IEqualityComparer<Track>
+    {
+        private bool _ignoreCase = false;
+        public TrackStringComparer(bool ignoreCase = false)
+        {
+            _ignoreCase = ignoreCase;
+        }
+
+        public bool Equals(Track a, Track b)
+        {
+            if (a.Equals(b))
+                return true;
+
+            var comparer = _ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
+
+            return string.Equals(a.Title, b.Title, comparer)
+                && string.Equals(a.Artist, b.Artist, comparer)
+                && string.Equals(a.Album, b.Album, comparer);
+        }
+
+        public int GetHashCode(Track a)
+        {
+            unchecked
+            {
+                int hash = 17;
+                string trackTitle = _ignoreCase ? a.Title.ToLower() : a.Title;
+                string artistName = _ignoreCase ? a.Artist.ToLower() : a.Artist;
+                string album = _ignoreCase ? a.Album.ToLower() : a.Album;
+
+                hash = hash * 23 + trackTitle.GetHashCode();
+                hash = hash * 23 + artistName.GetHashCode();
+                hash = hash * 23 + album.GetHashCode();
+
+                return hash;
+            }
+        }
+    }
+
+    public class SimpleFile
+    {
+        public string Path;
+        public string? Artists;
+        public string? Title;
+        public string? Album;
+        public int Length;
+        public int Bitrate;
+        public int Samplerate;
+        public int Bitdepth;
+
+        public SimpleFile(TagLib.File file)
+        {
+            Path = file.Name;
+            Artists = file.Tag.JoinedPerformers;
+            Title = file.Tag.Title;
+            Album = file.Tag.Album;
+            Length = (int)file.Length;
+            Bitrate = file.Properties.AudioBitrate;
+            Samplerate = file.Properties.AudioSampleRate;
+            Bitdepth = file.Properties.BitsPerSample;
+        }
+    }
+
+    public class ResponseData
+    {
+        public int lockedFilesCount;
+    }
+}
diff --git a/slsk-batchdl/Enums.cs b/slsk-batchdl/Enums.cs
new file mode 100644
index 0000000..dd43662
--- /dev/null
+++ b/slsk-batchdl/Enums.cs
@@ -0,0 +1,89 @@
+
+namespace Enums
+{
+    public enum FailureReason
+    {
+        None = 0,
+        InvalidSearchString = 1,
+        OutOfDownloadRetries = 2,
+        NoSuitableFileFound = 3,
+        AllDownloadsFailed = 4,
+    }
+
+    public enum TrackState
+    {
+        Initial = 0,
+        Downloaded = 1,
+        Failed = 2,
+        AlreadyExists = 3,
+        NotFoundLastTime = 4
+    }
+
+    public enum SkipMode
+    {
+        Name = 0,
+        NameCond = 1,
+        Tag = 2,
+        TagCond = 3, 
+        // non file-based skip modes are >= 4
+        M3u = 4,
+        M3uCond = 5,
+    }
+
+    public enum InputType
+    {
+        CSV,
+        YouTube,
+        Spotify,
+        Bandcamp,
+        String,
+        None,
+    }
+
+    public enum ListType
+    {
+        Normal,
+        Album,
+        Aggregate,
+        AlbumAggregate,
+    }
+
+    public enum M3uOption
+    {
+        None,
+        Index,
+        All,
+    }
+
+    public enum PrintOption
+    {
+        None = 0,
+        Tracks = 1,
+        Results = 2,
+        Full = 4,
+    }
+
+    public enum AlbumArtOption
+    {
+        Default,
+        Most,
+        Largest,
+        MostLargest,
+    }
+
+    public enum DisplayMode
+    {
+        Single,
+        Double,
+        Simple,
+    }
+
+    public enum Verbosity
+    {
+        Silent,
+        Error,
+        Warning,
+        Normal,
+        Verbose
+    }
+}
\ No newline at end of file
diff --git a/slsk-batchdl/ExistingChecker.cs b/slsk-batchdl/ExistingChecker.cs
new file mode 100644
index 0000000..babbb00
--- /dev/null
+++ b/slsk-batchdl/ExistingChecker.cs
@@ -0,0 +1,351 @@
+
+using Data;
+using Enums;
+using System.IO;
+
+namespace ExistingCheckers
+{
+    public static class Registry
+    {
+        static IExistingChecker GetChecker(SkipMode mode, string dir, FileConditions conditions, M3uEditor m3uEditor)
+        {
+            bool noConditions = conditions.Equals(new FileConditions());
+            return mode switch
+            {
+                SkipMode.Name => new NameExistingChecker(dir),
+                SkipMode.NameCond => noConditions ? new NameExistingChecker(dir) : new NameConditionExistingChecker(dir, conditions),
+                SkipMode.Tag => new TagExistingChecker(dir),
+                SkipMode.TagCond => noConditions ? new TagExistingChecker(dir) : new TagConditionExistingChecker(dir, conditions),
+                SkipMode.M3u => new M3uExistingChecker(m3uEditor, false),
+                SkipMode.M3uCond => noConditions ? new M3uExistingChecker(m3uEditor, true) : new M3uConditionExistingChecker(m3uEditor, conditions),
+            };
+        }
+
+        public static Dictionary<Track, string> SkipExisting(List<Track> tracks, string dir, FileConditions necessaryCond, M3uEditor m3uEditor, SkipMode mode)
+        {
+            var existing = new Dictionary<Track, string>();
+
+            var checker = GetChecker(mode, dir, necessaryCond, m3uEditor);
+            checker.BuildIndex();
+
+            for (int i = 0; i < tracks.Count; i++)
+            {
+                if (tracks[i].IsNotAudio)
+                    continue;
+
+                if (checker.TrackExists(tracks[i], out string? path))
+                {
+                    existing.TryAdd(tracks[i], path);
+                    tracks[i].State = TrackState.AlreadyExists;
+                    tracks[i].DownloadPath = path;
+                }
+            }
+
+            return existing;
+        }
+    }
+
+    public interface IExistingChecker
+    {
+        public bool TrackExists(Track track, out string? foundPath);
+        public void BuildIndex() { }
+    }
+
+    public class NameExistingChecker : IExistingChecker
+    {
+        readonly string[] ignore = new string[] { " ", "_", "-", ".", "(", ")", "[", "]" };
+        readonly string dir;
+        readonly List<(string, string, string)> index = new(); // (Path, PreprocessedPath, PreprocessedName)
+
+        public NameExistingChecker(string dir)
+        {
+            this.dir = dir;
+        }
+
+        private string Preprocess(string s, bool removeSlash)
+        {
+            s = s.ToLower().Replace(ignore, "");
+            s = s.ReplaceInvalidChars("", false, removeSlash);
+            s = s.RemoveFt();
+            s = s.RemoveDiacritics();
+            return s;
+        }
+
+        public void BuildIndex()
+        {
+            var files = Directory.GetFiles(dir, "*", SearchOption.AllDirectories);
+
+            int removeLen = Preprocess(dir, false).Length + 1;
+
+            foreach (var path in files)
+            {
+                if (Utils.IsMusicFile(path))
+                {
+                    string ppath = Preprocess(path[..path.LastIndexOf('.')], false)[removeLen..];
+                    string pname = Path.GetFileName(ppath);
+                    index.Add((path, ppath, pname));
+                }
+            }
+        }
+
+        public bool TrackExists(Track track, out string? foundPath)
+        {
+            string title = Preprocess(track.Title, true);
+            string artist = Preprocess(track.Artist, true);
+
+            foreach ((var path, var ppath, var pname) in index)
+            {
+                if (pname.Contains(title) && ppath.Contains(artist))
+                {
+                    foundPath = path;
+                    return true;
+                }
+            }
+
+            foundPath = null;
+            return false;
+        }
+    }
+
+    public class NameConditionExistingChecker : IExistingChecker
+    {
+        readonly string[] ignore = new string[] { " ", "_", "-", ".", "(", ")", "[", "]" };
+        readonly string dir;
+        readonly List<(string, string, SimpleFile)> index = new(); // (PreprocessedPath, PreprocessedName, file)
+        FileConditions conditions;
+
+        public NameConditionExistingChecker(string dir, FileConditions conditions)
+        {
+            this.dir = dir;
+            this.conditions = conditions;
+        }
+
+        private string Preprocess(string s, bool removeSlash)
+        {
+            s = s.ToLower().Replace(ignore, "");
+            s = s.ReplaceInvalidChars("", false, removeSlash);
+            s = s.RemoveFt();
+            s = s.RemoveDiacritics();
+            return s;
+        }
+
+        public void BuildIndex()
+        {
+            var files = Directory.GetFiles(dir, "*", SearchOption.AllDirectories);
+
+            int removeLen = Preprocess(dir, false).Length + 1;
+
+            foreach (var path in files)
+            {
+                if (Utils.IsMusicFile(path))
+                {
+                    TagLib.File musicFile;
+                    try { musicFile = TagLib.File.Create(path); }
+                    catch { continue; }
+
+                    string ppath = Preprocess(path[..path.LastIndexOf('.')], false)[removeLen..];
+                    string pname = Path.GetFileName(ppath);
+                    index.Add((ppath, pname, new SimpleFile(musicFile)));
+                }
+            }
+        }
+
+        public bool TrackExists(Track track, out string? foundPath)
+        {
+            string title = Preprocess(track.Title, true);
+            string artist = Preprocess(track.Artist, true);
+
+            foreach ((var ppath, var pname, var musicFile) in index)
+            {
+                if (pname.Contains(title) && ppath.Contains(artist) && conditions.FileSatisfies(musicFile, track))
+                {
+                    foundPath = musicFile.Path;
+                    return true;
+                }
+            }
+
+            foundPath = null;
+            return false;
+        }
+    }
+
+    public class TagExistingChecker : IExistingChecker
+    {
+        readonly string dir;
+        readonly List<(string, string, string)> index = new(); // (Path, PreprocessedArtist, PreprocessedTitle)
+
+        public TagExistingChecker(string dir)
+        {
+            this.dir = dir;
+        }
+
+        private string Preprocess(string s)
+        {
+            return s.Replace(" ", "").RemoveFt().ToLower();
+        }
+
+        public void BuildIndex()
+        {
+            var files = Directory.GetFiles(dir, "*", SearchOption.AllDirectories);
+
+            foreach (var path in files)
+            {
+                if (Utils.IsMusicFile(path))
+                {
+                    TagLib.File musicFile;
+                    try { musicFile = TagLib.File.Create(path); }
+                    catch { continue; }
+
+                    string partist = Preprocess(musicFile.Tag.JoinedPerformers ?? "");
+                    string ptitle = Preprocess(musicFile.Tag.Title ?? "");
+                    index.Add((path, partist, ptitle));
+                }
+            }
+        }
+
+        public bool TrackExists(Track track, out string? foundPath)
+        {
+            string title = Preprocess(track.Title);
+            string artist = Preprocess(track.Artist);
+
+            foreach ((var path, var partist, var ptitle) in index)
+            {
+                if (title==ptitle && partist.Contains(artist))
+                {
+                    foundPath = path;
+                    return true;
+                }
+            }
+
+            foundPath = null;
+            return false;
+        }
+    }
+
+    public class TagConditionExistingChecker : IExistingChecker
+    {
+        readonly string dir;
+        readonly List<(string, string, SimpleFile)> index = new(); // (PreprocessedArtist, PreprocessedTitle, file)
+        FileConditions conditions;
+
+        public TagConditionExistingChecker(string dir, FileConditions conditions)
+        {
+            this.dir = dir;
+            this.conditions = conditions;
+        }
+
+        private string Preprocess(string s)
+        {
+            return s.Replace(" ", "").RemoveFt().ToLower();
+        }
+
+        public void BuildIndex()
+        {
+            var files = Directory.GetFiles(dir, "*", SearchOption.AllDirectories);
+
+            foreach (var path in files)
+            {
+                if (Utils.IsMusicFile(path))
+                {
+                    TagLib.File musicFile;
+                    try { musicFile = TagLib.File.Create(path); }
+                    catch { continue; }
+
+                    string partist = Preprocess(musicFile.Tag.JoinedPerformers ?? "");
+                    string ptitle = Preprocess(musicFile.Tag.Title ?? "");
+                    index.Add((partist, ptitle, new SimpleFile(musicFile)));
+                }
+            }
+        }
+
+        public bool TrackExists(Track track, out string? foundPath)
+        {
+            string title = Preprocess(track.Title);
+            string artist = Preprocess(track.Artist);
+
+            foreach ((var partist, var ptitle, var musicFile) in index)
+            {
+                if (title == ptitle && partist.Contains(artist) && conditions.FileSatisfies(musicFile, track))
+                {
+                    foundPath = musicFile.Path;
+                    return true;
+                }
+            }
+
+            foundPath = null;
+            return false;
+        }
+    }
+
+    public class M3uExistingChecker : IExistingChecker
+    {
+        M3uEditor m3uEditor;
+        bool checkFileExists;
+        
+        public M3uExistingChecker(M3uEditor m3UEditor, bool checkFileExists) 
+        {
+            this.m3uEditor = m3UEditor;
+            this.checkFileExists = checkFileExists;
+        }
+
+        public bool TrackExists(Track track, out string? foundPath)
+        {
+            foundPath = null;
+            var t = m3uEditor.PreviousRunResult(track);
+            if (t != null && (t.State == TrackState.Downloaded || t.State == TrackState.AlreadyExists))
+            {
+                if (checkFileExists && (t.DownloadPath.Length == 0 || !File.Exists(t.DownloadPath)))
+                {
+                    return false;
+                }
+                foundPath = t.DownloadPath;
+                return true;
+            }
+            return false;
+        }
+    }
+
+    public class M3uConditionExistingChecker : IExistingChecker
+    {
+        M3uEditor m3uEditor;
+        FileConditions conditions;
+
+        public M3uConditionExistingChecker(M3uEditor m3UEditor, FileConditions conditions)
+        {
+            this.m3uEditor = m3UEditor;
+            this.conditions = conditions;
+        }
+
+        public bool TrackExists(Track track, out string? foundPath)
+        {
+            foundPath = null;
+            var t = m3uEditor.PreviousRunResult(track);
+            if (t != null && (t.State == TrackState.Downloaded || t.State == TrackState.AlreadyExists) && t.DownloadPath.Length > 0)
+            {
+                if (File.Exists(t.DownloadPath))
+                {
+                    TagLib.File musicFile;
+                    try 
+                    { 
+                        musicFile = TagLib.File.Create(t.DownloadPath);
+                        if (conditions.FileSatisfies(musicFile, track, false))
+                        {
+                            foundPath = t.DownloadPath;
+                            return true;
+                        }
+                        else
+                        {
+                            return false;
+                        }
+                    }
+                    catch 
+                    { 
+                        return false;
+                    }
+
+                }
+            }
+            return false;
+        }
+    }
+}
\ No newline at end of file
diff --git a/slsk-batchdl/Extractors/Bandcamp.cs b/slsk-batchdl/Extractors/Bandcamp.cs
new file mode 100644
index 0000000..4c58f77
--- /dev/null
+++ b/slsk-batchdl/Extractors/Bandcamp.cs
@@ -0,0 +1,109 @@
+using Data;
+using HtmlAgilityPack;
+
+using Enums;
+using System.Net;
+using System.Text.RegularExpressions;
+using System.Text.Json;
+
+namespace Extractors
+{
+    public class BandcampExtractor : IExtractor
+    {
+        public static bool InputMatches(string input)
+        {
+            input = input.ToLower();
+            return input.IsInternetUrl() && input.Contains("bandcamp.com");
+        }
+
+        public async Task<TrackLists> GetTracks()
+        {
+            var trackLists = new TrackLists();
+            bool isTrack = Config.input.Contains("/track/");
+            bool isAlbum = !isTrack && Config.input.Contains("/album/");
+            bool isArtist =!isTrack && !isAlbum;
+
+            if (isArtist)
+            {
+                string artistUrl = Config.input.TrimEnd('/');
+
+                if (!artistUrl.EndsWith("/music"))
+                    artistUrl += "/music";
+
+                using var httpClient = new HttpClient();
+                var response = await httpClient.GetStringAsync(artistUrl);
+
+                string idPattern = @"band_id=(\d+)&";
+                var match = Regex.Match(response, idPattern);
+                var id = match.Groups[1].Value;
+
+                var address = $"http://bandcamp.com/api/mobile/24/band_details?band_id={id}";
+
+                var responseString = await httpClient.GetStringAsync(address);
+                var jsonDocument = JsonDocument.Parse(responseString);
+                var root = jsonDocument.RootElement;
+
+                string artistName = root.GetProperty("name").GetString();
+
+                var tralbums = new List<Track>();
+
+                foreach (var item in root.GetProperty("discography").EnumerateArray())
+                {
+                    //ItemType = item.GetProperty("item_type").GetString(),
+                    var t = new Track()
+                    {
+                        Album = item.GetProperty("title").GetString(),
+                        Artist = item.GetProperty("artist_name").GetString() ?? item.GetProperty("band_name").GetString(),
+                        IsAlbum = true,
+                    };
+                    trackLists.AddEntry(ListType.Album, t);
+                }
+            }
+            else
+            {
+                var web = new HtmlWeb();
+                var doc = await web.LoadFromWebAsync(Config.input);
+
+                var nameSection = doc.DocumentNode.SelectSingleNode("//div[@id='name-section']");
+                var name = nameSection.SelectSingleNode(".//h2[contains(@class, 'trackTitle')]").InnerText.UnHtmlString().Trim();
+
+                if (isAlbum)
+                {
+                    var artist = nameSection.SelectSingleNode(".//h3/span/a").InnerText.UnHtmlString().Trim();
+                    var track = new Track() { Artist = artist, Album = name, IsAlbum = true };
+                    trackLists.AddEntry(ListType.Album, track);
+
+                    if (Config.setAlbumMinTrackCount || Config.setAlbumMaxTrackCount)
+                    {
+                        var trackTable = doc.DocumentNode.SelectSingleNode("//*[@id='track_table']");
+                        int n = trackTable.SelectNodes(".//tr").Count;
+
+                        if (Config.setAlbumMinTrackCount)
+                            track.MinAlbumTrackCount = n;
+
+                        if (Config.setAlbumMaxTrackCount)
+                            track.MaxAlbumTrackCount = n;
+                    }
+
+                    Config.defaultFolderName = track.ToString(true).ReplaceInvalidChars(Config.invalidReplaceStr).Trim();
+                }
+                else
+                {
+                    var album = nameSection.SelectSingleNode(".//h3[contains(@class, 'albumTitle')]/span/a").InnerText.UnHtmlString().Trim();
+                    var artist = nameSection.SelectSingleNode(".//h3[contains(@class, 'albumTitle')]/span[last()]/a").InnerText.UnHtmlString().Trim();
+                    //var timeParts = doc.DocumentNode.SelectSingleNode("//span[@class='time_total']").InnerText.Trim().Split(':');
+                    var track = new Track() { Artist = artist, Title = name, Album = album };
+                    trackLists.AddEntry(track);
+                    Config.defaultFolderName = ".";
+                }
+            }
+
+            if (!Config.reverse)
+            {
+                trackLists = TrackLists.FromFlattened(trackLists.Flattened(true, false).Skip(Config.offset).Take(Config.maxTracks), Config.aggregate, Config.album);
+            }
+
+            return trackLists;
+        }
+    }
+}
\ No newline at end of file
diff --git a/slsk-batchdl/Extractors/Csv.cs b/slsk-batchdl/Extractors/Csv.cs
new file mode 100644
index 0000000..f28f35e
--- /dev/null
+++ b/slsk-batchdl/Extractors/Csv.cs
@@ -0,0 +1,209 @@
+using Data;
+using System.Text.RegularExpressions;
+
+namespace Extractors
+{
+    public class CsvExtractor : IExtractor
+    {
+        object csvLock = new();
+        int csvColumnCount = -1;
+
+        public static bool InputMatches(string input)
+        {
+            input = input.ToLower();
+            return !input.IsInternetUrl() && input.EndsWith(".csv");
+        }
+
+        public async Task<TrackLists> GetTracks()
+        {
+            int max = Config.reverse ? int.MaxValue : Config.maxTracks;
+            int off = Config.reverse ? 0 : Config.offset;
+
+            if (!File.Exists(Config.input))
+                throw new FileNotFoundException("CSV file not found");
+
+            var tracks = await ParseCsvIntoTrackInfo(Config.input, Config.artistCol, Config.trackCol, Config.lengthCol, Config.albumCol, Config.descCol, Config.ytIdCol, Config.trackCountCol, Config.timeUnit, Config.ytParse);
+            var trackLists = TrackLists.FromFlattened(tracks.Skip(off).Take(max), Config.aggregate, Config.album);
+            Config.defaultFolderName = Path.GetFileNameWithoutExtension(Config.input);
+
+            return trackLists;
+        }
+
+        public async Task RemoveTrackFromSource(Track track)
+        {
+            lock (csvLock)
+            {
+                if (File.Exists(Config.input))
+                {
+                    string[] lines = File.ReadAllLines(Config.input, System.Text.Encoding.UTF8);
+
+                    if (lines.Length > track.CsvRow)
+                    {
+                        lines[track.CsvRow] = new string(',', Math.Max(0, csvColumnCount - 1));
+                        Utils.WriteAllLines(Config.input, lines, '\n');
+                    }
+                }
+            }
+        }
+
+        async Task<List<Track>> ParseCsvIntoTrackInfo(string path, string artistCol = "", string trackCol = "",
+            string lengthCol = "", string albumCol = "", string descCol = "", string ytIdCol = "", string trackCountCol = "", string timeUnit = "s", bool ytParse = false)
+        {
+            var tracks = new List<Track>();
+            using var sr = new StreamReader(path, System.Text.Encoding.UTF8);
+            var parser = new SmallestCSV.SmallestCSVParser(sr);
+
+            int index = 0;
+            var header = parser.ReadNextRow();
+            while (header == null || header.Count == 0 || !header.Any(t => t.Trim().Length > 0))
+            {
+                index++;
+                header = parser.ReadNextRow();
+            }
+
+            string[] cols = { artistCol, albumCol, trackCol, lengthCol, descCol, ytIdCol, trackCountCol };
+            string[][] aliases = {
+                new[] { "artist", "artist name", "artists", "artist names" },
+                new[] { "album", "album name", "album title" },
+                new[] { "title", "song", "track title", "track name", "song name", "track" },
+                new[] { "length", "duration", "track length", "track duration", "song length", "song duration" },
+                new[] { "description", "youtube description" },
+                new[] { "url", "id", "youtube id" },
+                new[] { "track count", "album track count" }
+            };
+
+            string usingColumns = "";
+            for (int i = 0; i < cols.Length; i++)
+            {
+                if (string.IsNullOrEmpty(cols[i]))
+                {
+                    string? res = header.FirstOrDefault(h => Regex.Replace(h, @"\(.*?\)", "").Trim().EqualsAny(aliases[i], StringComparison.OrdinalIgnoreCase));
+                    if (!string.IsNullOrEmpty(res))
+                    {
+                        cols[i] = res;
+                        usingColumns += $"{aliases[i][0]}:\"{res}\", ";
+                    }
+                }
+                else
+                {
+                    if (header.IndexOf(cols[i]) == -1)
+                        throw new Exception($"Column \"{cols[i]}\" not found in CSV file");
+                    usingColumns += $"{aliases[i][0]}:\"{cols[i]}\", ";
+                }
+            }
+
+            int foundCount = cols.Count(col => col.Length > 0);
+            if (!string.IsNullOrEmpty(usingColumns))
+                Console.WriteLine($"Using columns: {usingColumns.TrimEnd(' ', ',')}.");
+            else if (foundCount == 0)
+                throw new Exception("No columns specified and couldn't determine automatically");
+
+            int[] indices = cols.Select(col => col.Length == 0 ? -1 : header.IndexOf(col)).ToArray();
+            int artistIndex, albumIndex, trackIndex, lengthIndex, descIndex, ytIdIndex, trackCountIndex;
+            (artistIndex, albumIndex, trackIndex, lengthIndex, descIndex, ytIdIndex, trackCountIndex) = (indices[0], indices[1], indices[2], indices[3], indices[4], indices[5], indices[6]);
+
+            while (true)
+            {
+                index++;
+                var values = parser.ReadNextRow();
+                if (values == null)
+                    break;
+                if (!values.Any(t => t.Trim().Length > 0))
+                    continue;
+                while (values.Count < foundCount)
+                    values.Add("");
+
+                if (csvColumnCount == -1)
+                    csvColumnCount = values.Count;
+
+                var desc = "";
+                var track = new Track() { CsvRow = index };
+
+                if (artistIndex >= 0) track.Artist = values[artistIndex];
+                if (trackIndex >= 0) track.Title = values[trackIndex];
+                if (albumIndex >= 0) track.Album = values[albumIndex];
+                if (descIndex >= 0) desc = values[descIndex];
+                if (ytIdIndex >= 0) track.URI = values[ytIdIndex];
+                if (trackCountIndex >= 0)
+                {
+                    string a = values[trackCountIndex].Trim();
+                    if (a == "-1")
+                    {
+                        track.MinAlbumTrackCount = -1;
+                        track.MaxAlbumTrackCount = -1;
+                    }
+                    else if (a.Last() == '-' && int.TryParse(a.AsSpan(0, a.Length - 1), out int n))
+                    {
+                        track.MaxAlbumTrackCount = n;
+                    }
+                    else if (a.Last() == '+' && int.TryParse(a.AsSpan(0, a.Length - 1), out n))
+                    {
+                        track.MinAlbumTrackCount = n;
+                    }
+                    else if (int.TryParse(a, out n))
+                    {
+                        track.MinAlbumTrackCount = n;
+                        track.MaxAlbumTrackCount = n;
+                    }
+                }
+                if (lengthIndex >= 0)
+                {
+                    try
+                    {
+                        track.Length = (int)ParseTrackLength(values[lengthIndex], timeUnit);
+                    }
+                    catch
+                    {
+                        Program.WriteLine($"Couldn't parse track length \"{values[lengthIndex]}\" with format \"{timeUnit}\" for \"{track}\"", ConsoleColor.DarkYellow);
+                    }
+                }
+
+                if (ytParse)
+                    track = await YouTube.ParseTrackInfo(track.Title, track.Artist, track.URI, track.Length, desc);
+
+                track.IsAlbum = track.Title.Length == 0 && track.Album.Length > 0;
+
+                if (track.Title.Length > 0 || track.Artist.Length > 0 || track.Album.Length > 0)
+                    tracks.Add(track);
+            }
+
+            if (ytParse)
+                YouTube.StopService();
+
+            return tracks;
+        }
+
+        double ParseTrackLength(string duration, string format)
+        {
+            if (string.IsNullOrEmpty(format))
+                throw new ArgumentException("Duration format string empty");
+            duration = Regex.Replace(duration, "[a-zA-Z]", "");
+            var formatParts = Regex.Split(format, @"\W+");
+            var durationParts = Regex.Split(duration, @"\W+").Where(s => !string.IsNullOrEmpty(s)).ToArray();
+
+            double totalSeconds = 0;
+
+            for (int i = 0; i < formatParts.Length; i++)
+            {
+                switch (formatParts[i])
+                {
+                    case "h":
+                        totalSeconds += double.Parse(durationParts[i]) * 3600;
+                        break;
+                    case "m":
+                        totalSeconds += double.Parse(durationParts[i]) * 60;
+                        break;
+                    case "s":
+                        totalSeconds += double.Parse(durationParts[i]);
+                        break;
+                    case "ms":
+                        totalSeconds += double.Parse(durationParts[i]) / Math.Pow(10, durationParts[i].Length);
+                        break;
+                }
+            }
+
+            return totalSeconds;
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/slsk-batchdl/Extractors/Spotify.cs b/slsk-batchdl/Extractors/Spotify.cs
new file mode 100644
index 0000000..7423fea
--- /dev/null
+++ b/slsk-batchdl/Extractors/Spotify.cs
@@ -0,0 +1,341 @@
+using SpotifyAPI.Web;
+using SpotifyAPI.Web.Auth;
+using Swan;
+
+using Data;
+using Enums;
+
+namespace Extractors
+{
+    public class SpotifyExtractor : IExtractor
+    {
+        private Spotify? spotifyClient;
+        public string playlistUri = "";
+
+        public static bool InputMatches(string input)
+        {
+            input = input.ToLower();
+            return input == "spotify-likes" || input.IsInternetUrl() && input.Contains("spotify.com");
+        }
+
+        public async Task<TrackLists> GetTracks()
+        {
+            var trackLists = new TrackLists();
+            int max = Config.reverse ? int.MaxValue : Config.maxTracks;
+            int off = Config.reverse ? 0 : Config.offset;
+
+            string playlistName = "";
+            bool needLogin = Config.input == "spotify-likes" || Config.removeTracksFromSource;
+            List<Track> tracks = new List<Track>();
+
+            static void readSpotifyCreds()
+            {
+                Console.Write("Spotify client ID:");
+                Config.spotifyId = Console.ReadLine();
+                Console.Write("Spotify client secret:");
+                Config.spotifySecret = Console.ReadLine();
+                Console.WriteLine();
+            }
+
+            if (needLogin && (Config.spotifyId.Length == 0 || Config.spotifySecret.Length == 0))
+            {
+                readSpotifyCreds();
+            }
+
+            spotifyClient = new Spotify(Config.spotifyId, Config.spotifySecret);
+            await spotifyClient.Authorize(needLogin, Config.removeTracksFromSource);
+
+            if (Config.input == "spotify-likes")
+            {
+                Console.WriteLine("Loading Spotify likes");
+                tracks = await spotifyClient.GetLikes(max, off);
+                playlistName = "Spotify Likes";
+
+                trackLists.AddEntry(tracks);
+                if (Config.album || Config.aggregate)
+                    trackLists = TrackLists.FromFlattened(trackLists.Flattened(true, false), Config.aggregate, Config.album);
+            }
+            else if (Config.input.Contains("/album/"))
+            {
+                Console.WriteLine("Loading Spotify album");
+                (var source, tracks) = await spotifyClient.GetAlbum(Config.input);
+                playlistName = source.ToString(noInfo: true);
+                trackLists.AddEntry(ListType.Album, source);
+
+                if (Config.setAlbumMinTrackCount)
+                    source.MinAlbumTrackCount = tracks.Count;
+
+                if (Config.setAlbumMaxTrackCount)
+                    source.MaxAlbumTrackCount = tracks.Count;
+            }
+            else if (Config.input.Contains("/artist/"))
+            {
+                Console.WriteLine("Loading spotify artist");
+                throw new NotImplementedException("Spotify artist download currently not supported.");
+            }
+            else
+            {
+                try
+                {
+                    Console.WriteLine("Loading Spotify playlist");
+                    (playlistName, playlistUri, tracks) = await spotifyClient.GetPlaylist(Config.input, max, off);
+                }
+                catch (SpotifyAPI.Web.APIException)
+                {
+                    if (!needLogin && !spotifyClient.UsedDefaultCredentials)
+                    {
+                        await spotifyClient.Authorize(true, Config.removeTracksFromSource);
+                        (playlistName, playlistUri, tracks) = await spotifyClient.GetPlaylist(Config.input, max, off);
+                    }
+                    else if (!needLogin)
+                    {
+                        Console.WriteLine("Spotify playlist not found. It may be set to private. Login? [Y/n]");
+                        if (Console.ReadLine()?.ToLower().Trim() == "y")
+                        {
+                            readSpotifyCreds();
+                            spotifyClient = new Spotify(Config.spotifyId, Config.spotifySecret);
+                            await spotifyClient.Authorize(true, Config.removeTracksFromSource);
+                            Console.WriteLine("Loading Spotify playlist");
+                            (playlistName, playlistUri, tracks) = await spotifyClient.GetPlaylist(Config.input, max, off);
+                        }
+                        else
+                        {
+                            Environment.Exit(0);
+                        }
+                    }
+                    else throw;
+                }
+                trackLists.AddEntry(tracks);
+                if (Config.album || Config.aggregate)
+                    trackLists = TrackLists.FromFlattened(trackLists.Flattened(true, false), Config.aggregate, Config.album);
+            }
+
+            Config.defaultFolderName = playlistName.ReplaceInvalidChars(Config.invalidReplaceStr);
+
+            return trackLists;
+        }
+
+        public async Task RemoveTrackFromSource(Track track)
+        {
+            if (playlistUri.Length > 0 && track.URI.Length > 0)
+                await spotifyClient.RemoveTrackFromPlaylist(playlistUri, track.URI);
+        }
+    }
+
+
+    public class Spotify
+    {
+        private EmbedIOAuthServer _server;
+        private readonly string _clientId;
+        private readonly string _clientSecret;
+        private SpotifyClient? _client;
+        private bool loggedIn = false;
+
+        // default spotify credentials (base64-encoded to keep the bots away)
+        public const string encodedSpotifyId = "MWJmNDY5M1bLaH9WJiYjFhNGY0MWJjZWQ5YjJjMWNmZGJiZDI=";
+        public const string encodedSpotifySecret = "Y2JlM2QxYTE5MzJkNDQ2MmFiOGUy3shTuf4Y2JhY2M3ZDdjYWU=";
+        public bool UsedDefaultCredentials { get; private set; }
+
+        public Spotify(string clientId = "", string clientSecret = "")
+        {
+            _clientId = clientId;
+            _clientSecret = clientSecret;
+
+            if (_clientId.Length == 0 || _clientSecret.Length == 0)
+            {
+                _clientId = System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(encodedSpotifyId.Replace("1bLaH9", "")));
+                _clientSecret = System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(encodedSpotifySecret.Replace("3shTuf4", "")));
+                UsedDefaultCredentials = true;
+            }
+        }
+
+        public async Task Authorize(bool login = false, bool needModify = false)
+        {
+            _client = null;
+
+            if (!login)
+            {
+                var config = SpotifyClientConfig.CreateDefault();
+
+                var request = new ClientCredentialsRequest(_clientId, _clientSecret);
+                var response = await new OAuthClient(config).RequestToken(request);
+
+                _client = new SpotifyClient(config.WithToken(response.AccessToken));
+            }
+            else
+            {
+                Swan.Logging.Logger.NoLogging();
+                _server = new EmbedIOAuthServer(new Uri("http://localhost:48721/callback"), 48721);
+                await _server.Start();
+
+                _server.AuthorizationCodeReceived += OnAuthorizationCodeReceived;
+                _server.ErrorReceived += OnErrorReceived;
+
+                var scope = new List<string> {
+                    Scopes.UserLibraryRead, Scopes.PlaylistReadPrivate, Scopes.PlaylistReadCollaborative
+                };
+
+                if (needModify)
+                {
+                    scope.Add(Scopes.PlaylistModifyPublic);
+                    scope.Add(Scopes.PlaylistModifyPrivate);
+                }
+
+                var request = new LoginRequest(_server.BaseUri, _clientId, LoginRequest.ResponseType.Code) { Scope = scope };
+
+                BrowserUtil.Open(request.ToUri());
+
+                await IsClientReady();
+            }
+        }
+
+        private async Task OnAuthorizationCodeReceived(object sender, AuthorizationCodeResponse response)
+        {
+            await _server.Stop();
+
+            var config = SpotifyClientConfig.CreateDefault();
+            var tokenResponse = await new OAuthClient(config).RequestToken(
+                new AuthorizationCodeTokenRequest(
+                    _clientId, _clientSecret, response.Code, new Uri("http://localhost:48721/callback")
+                )
+            );
+
+            _client = new SpotifyClient(tokenResponse.AccessToken);
+            loggedIn = true;
+        }
+
+        private async Task OnErrorReceived(object sender, string error, string state)
+        {
+            await _server.Stop();
+            throw new Exception($"Aborting authorization, error received: {error}");
+        }
+
+        public async Task<bool> IsClientReady()
+        {
+            while (_client == null)
+                await Task.Delay(1000);
+            return true;
+        }
+
+        public async Task<List<Track>> GetLikes(int max = int.MaxValue, int offset = 0)
+        {
+            if (!loggedIn)
+                throw new Exception("Can't get liked music as user is not logged in");
+
+            List<Track> res = new List<Track>();
+            int limit = Math.Min(max, 50);
+
+            while (true)
+            {
+                var tracks = await _client.Library.GetTracks(new LibraryTracksRequest { Limit = limit, Offset = offset });
+
+                foreach (var track in tracks.Items)
+                {
+                    string[] artists = ((IEnumerable<object>)track.Track.ReadProperty("artists")).Select(a => (string)a.ReadProperty("name")).ToArray();
+                    string artist = artists[0];
+                    string name = (string)track.Track.ReadProperty("name");
+                    string album = (string)track.Track.ReadProperty("album").ReadProperty("name");
+                    int duration = (int)track.Track.ReadProperty("durationMs");
+                    res.Add(new Track { Album = album, Artist = artist, Title = name, Length = duration / 1000 });
+                }
+
+                if (tracks.Items.Count < limit || res.Count >= max)
+                    break;
+
+                offset += limit;
+                limit = Math.Min(max - res.Count, 50);
+            }
+
+            return res;
+        }
+
+        public async Task RemoveTrackFromPlaylist(string playlistId, string trackUri)
+        {
+            var item = new PlaylistRemoveItemsRequest.Item { Uri = trackUri };
+            var pr = new PlaylistRemoveItemsRequest();
+            pr.Tracks = new List<PlaylistRemoveItemsRequest.Item>() { item };
+            try { await _client.Playlists.RemoveItems(playlistId, pr); }
+            catch { }
+        }
+
+        public async Task<(string?, string?, List<Track>)> GetPlaylist(string url, int max = int.MaxValue, int offset = 0)
+        {
+            var playlistId = GetPlaylistIdFromUrl(url);
+            var p = await _client.Playlists.Get(playlistId);
+
+            List<Track> res = new List<Track>();
+            int limit = Math.Min(max, 100);
+
+            while (true)
+            {
+                var tracks = await _client.Playlists.GetItems(playlistId, new PlaylistGetItemsRequest { Limit = limit, Offset = offset });
+
+                foreach (var track in tracks.Items)
+                {
+                    try
+                    {
+                        string[] artists = ((IEnumerable<object>)track.Track.ReadProperty("artists")).Select(a => (string)a.ReadProperty("name")).ToArray();
+                        var t = new Track()
+                        {
+                            Artist = artists[0],
+                            Album = (string)track.Track.ReadProperty("album").ReadProperty("name"),
+                            Title = (string)track.Track.ReadProperty("name"),
+                            Length = (int)track.Track.ReadProperty("durationMs") / 1000,
+                            URI = (string)track.Track.ReadProperty("uri"),
+                        };
+                        res.Add(t);
+                    }
+                    catch
+                    {
+                        continue;
+                    }
+                }
+
+                if (tracks.Items.Count < limit || res.Count >= max)
+                    break;
+
+                offset += limit;
+                limit = Math.Min(max - res.Count, 100);
+            }
+
+            return (p.Name, p.Id, res);
+        }
+
+        private string GetPlaylistIdFromUrl(string url)
+        {
+            var uri = new Uri(url);
+            var segments = uri.Segments;
+            return segments[segments.Length - 1].TrimEnd('/');
+        }
+
+        public async Task<(Track, List<Track>)> GetAlbum(string url)
+        {
+            var albumId = GetAlbumIdFromUrl(url);
+            var album = await _client.Albums.Get(albumId);
+
+            List<Track> tracks = new List<Track>();
+
+            foreach (var track in album.Tracks.Items)
+            {
+                var t = new Track()
+                {
+                    Album = album.Name,
+                    Artist = track.Artists.First().Name,
+                    Title = track.Name,
+                    Length = track.DurationMs / 1000,
+                    URI = track.Uri,
+                };
+                tracks.Add(t);
+            }
+
+            return (new Track { Album = album.Name, Artist = album.Artists.First().Name, IsAlbum = true }, tracks);
+        }
+
+        private string GetAlbumIdFromUrl(string url)
+        {
+            var uri = new Uri(url);
+            var segments = uri.Segments;
+            return segments[^1].TrimEnd('/');
+        }
+    }
+}
diff --git a/slsk-batchdl/Extractors/String.cs b/slsk-batchdl/Extractors/String.cs
new file mode 100644
index 0000000..2580c48
--- /dev/null
+++ b/slsk-batchdl/Extractors/String.cs
@@ -0,0 +1,169 @@
+
+using Data;
+using Enums;
+
+namespace Extractors
+{
+    public class StringExtractor : IExtractor
+    {
+        public static bool InputMatches(string input)
+        {
+            return !input.IsInternetUrl();
+        }
+
+        public async Task<TrackLists> GetTracks()
+        {
+            var trackLists = new TrackLists();
+            var music = ParseTrackArg(Config.input, Config.album);
+            bool isAlbum = false;
+
+            if (Config.album && Config.aggregate)
+            {
+                trackLists.AddEntry(ListType.AlbumAggregate, music);
+            }
+            else if (Config.album)
+            {
+                music.IsAlbum = true;
+                trackLists.AddEntry(ListType.Album, music);
+            }
+            else if (!Config.aggregate && music.Title.Length > 0)
+            {
+                trackLists.AddEntry(music);
+            }
+            else if (Config.aggregate)
+            {
+                trackLists.AddEntry(ListType.Aggregate, music);
+            }
+            else if (music.Title.Length == 0 && music.Album.Length > 0)
+            {
+                isAlbum = true;
+                music.IsAlbum = true;
+                trackLists.AddEntry(ListType.Album, music);
+            }
+            else
+            {
+                throw new ArgumentException("Need track title or album");
+            }
+
+            if (Config.aggregate || isAlbum || Config.album)
+                Config.defaultFolderName = music.ToString(true).ReplaceInvalidChars(Config.invalidReplaceStr).Trim();
+            else
+                Config.defaultFolderName = ".";
+
+            return trackLists;
+        }
+
+        public Track ParseTrackArg(string input, bool isAlbum)
+        {
+            input = input.Trim();
+            var track = new Track();
+            var keys = new string[] { "title", "artist", "length", "album", "artist-maybe-wrong" };
+
+            track.IsAlbum = isAlbum;
+
+            void setProperty(string key, string value)
+            {
+                switch (key)
+                {
+                    case "title":
+                        track.Title = value;
+                        break;
+                    case "artist":
+                        track.Artist = value;
+                        break;
+                    case "length":
+                        track.Length = int.Parse(value);
+                        break;
+                    case "album":
+                        track.Album = value;
+                        break;
+                    case "artist-maybe-wrong":
+                        if (value == "true") track.ArtistMaybeWrong = true;
+                        break;
+                }
+            }
+
+            var parts = input.Split(',');
+            var other = "";
+            string? currentKey = null;
+            string? currentVal = null;
+            bool otherFieldDone = false;
+
+            for (int i = 0; i < parts.Length; i++)
+            {
+                var x = parts[i];
+                bool keyval = false;
+
+                if (x.Contains('='))
+                {
+                    var lr = x.Split('=', 2);
+                    lr[0] = lr[0].Trim();
+                    if (lr.Length == 2 && lr[1].Length > 0 && keys.Contains(lr[0]))
+                    {
+                        if (currentKey != null && currentVal != null)
+                            setProperty(currentKey, currentVal.Trim());
+                        currentKey = lr[0];
+                        currentVal = lr[1];
+                        keyval = true;
+                        otherFieldDone = true;
+                    }
+                }
+
+                if (!keyval && currentVal != null)
+                {
+                    currentVal += ',' + x;
+                }
+
+                if (!otherFieldDone)
+                {
+                    if (i > 0) other += ',';
+                    other += x;
+                }
+            }
+
+            if (currentKey != null && currentVal != null)
+                setProperty(currentKey, currentVal.Trim());
+
+            other = other.Trim();
+            if (other.Length > 0)
+            {
+                string artist = "", album = "", title = "";
+                parts = other.Split(" - ", StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries);
+                if (parts.Length == 1 || parts.Length > 3)
+                {
+                    if (isAlbum)
+                        album = other.Trim();
+                    else
+                        title = other.Trim();
+                }
+                else if (parts.Length == 2)
+                {
+                    artist = parts[0];
+
+                    if (isAlbum)
+                        album = parts[1];
+                    else
+                        title = parts[1];
+                }
+                else if (parts.Length == 3)
+                {
+                    artist = parts[0];
+                    album = parts[1];
+                    title = parts[2];
+                }
+
+                if (track.Artist.Length == 0)
+                    track.Artist = artist;
+                if (track.Album.Length == 0)
+                    track.Album = album;
+                if (track.Title.Length == 0)
+                    track.Title = title;
+            }
+
+            if (track.Title.Length == 0 && track.Album.Length == 0 && track.Artist.Length == 0)
+                throw new ArgumentException("Track string must contain title, album or artist.");
+
+            return track;
+        }
+    }
+}
diff --git a/slsk-batchdl/Extractors/YouTube.cs b/slsk-batchdl/Extractors/YouTube.cs
new file mode 100644
index 0000000..7b9e276
--- /dev/null
+++ b/slsk-batchdl/Extractors/YouTube.cs
@@ -0,0 +1,675 @@
+using Google.Apis.YouTube.v3;
+using Google.Apis.Services;
+using System.Xml;
+using YoutubeExplode;
+using System.Text.RegularExpressions;
+using YoutubeExplode.Common;
+using System.Diagnostics;
+using HtmlAgilityPack;
+using System.Collections.Concurrent;
+
+using Data;
+
+namespace Extractors
+{
+    public class YouTubeExtractor : IExtractor
+    {
+        public static bool InputMatches(string input)
+        {
+            input = input.ToLower();
+            return input.IsInternetUrl() && (input.Contains("youtu.be") || input.Contains("youtube.com"));
+        }
+
+        public async Task<TrackLists> GetTracks()
+        {
+            var trackLists = new TrackLists();
+            int max = Config.reverse ? int.MaxValue : Config.maxTracks;
+            int off = Config.reverse ? 0 : Config.offset;
+            YouTube.apiKey = Config.ytKey;
+
+            string name;
+            List<Track>? deleted = null;
+            List<Track> tracks = new();
+
+            if (Config.getDeleted)
+            {
+                Console.WriteLine("Getting deleted videos..");
+                var archive = new YouTube.YouTubeArchiveRetriever();
+                deleted = await archive.RetrieveDeleted(Config.input, printFailed: Config.deletedOnly);
+            }
+            if (!Config.deletedOnly)
+            {
+                if (YouTube.apiKey.Length > 0)
+                {
+                    Console.WriteLine("Loading YouTube playlist (API)");
+                    (name, tracks) = await YouTube.GetTracksApi(Config.input, max, off);
+                }
+                else
+                {
+                    Console.WriteLine("Loading YouTube playlist");
+                    (name, tracks) = await YouTube.GetTracksYtExplode(Config.input, max, off);
+                }
+            }
+            else
+            {
+                name = await YouTube.GetPlaylistTitle(Config.input);
+            }
+            if (deleted != null)
+            {
+                tracks.InsertRange(0, deleted);
+            }
+
+            YouTube.StopService();
+            trackLists.AddEntry(tracks);
+
+            if (Config.album || Config.aggregate)
+                trackLists = TrackLists.FromFlattened(trackLists.Flattened(true, false), Config.aggregate, Config.album);
+            Config.defaultFolderName = name.ReplaceInvalidChars(Config.invalidReplaceStr);
+
+            return trackLists;
+        }
+    }
+
+
+    public static class YouTube
+    {
+        private static YoutubeClient? youtube = new YoutubeClient();
+        private static YouTubeService? youtubeService = null;
+        public static string apiKey = "";
+
+        public static async Task<(string, List<Track>)> GetTracksApi(string url, int max = int.MaxValue, int offset = 0)
+        {
+            StartService();
+
+            string playlistId = await UrlToId(url);
+
+            var playlistRequest = youtubeService.Playlists.List("snippet");
+            playlistRequest.Id = playlistId;
+            var playlistResponse = playlistRequest.Execute();
+
+            string playlistName = playlistResponse.Items[0].Snippet.Title;
+
+            var playlistItemsRequest = youtubeService.PlaylistItems.List("snippet,contentDetails");
+            playlistItemsRequest.PlaylistId = playlistId;
+            playlistItemsRequest.MaxResults = Math.Min(max, 100);
+
+            var tracksDict = await GetDictYtExplode(url, max, offset);
+            var tracks = new List<Track>();
+            int count = 0;
+
+            while (playlistItemsRequest != null && count < max + offset)
+            {
+                var playlistItemsResponse = playlistItemsRequest.Execute();
+                foreach (var playlistItem in playlistItemsResponse.Items)
+                {
+                    if (count >= offset)
+                    {
+                        if (tracksDict.ContainsKey(playlistItem.Snippet.ResourceId.VideoId))
+                            tracks.Add(tracksDict[playlistItem.Snippet.ResourceId.VideoId]);
+                        else
+                        {
+                            var title = "";
+                            var uploader = "";
+                            var length = 0;
+                            var desc = "";
+
+                            var videoRequest = youtubeService.Videos.List("contentDetails,snippet");
+                            videoRequest.Id = playlistItem.Snippet.ResourceId.VideoId;
+                            var videoResponse = videoRequest.Execute();
+
+                            title = playlistItem.Snippet.Title;
+                            if (videoResponse.Items.Count == 0)
+                                continue;
+                            uploader = videoResponse.Items[0].Snippet.ChannelTitle;
+                            length = (int)XmlConvert.ToTimeSpan(videoResponse.Items[0].ContentDetails.Duration).TotalSeconds;
+                            desc = videoResponse.Items[0].Snippet.Description;
+
+                            Track track = await ParseTrackInfo(title, uploader, playlistItem.Snippet.ResourceId.VideoId, length, desc);
+                            tracks.Add(track);
+                        }
+                    }
+
+                    if (++count >= max + offset)
+                        break;
+                }
+
+                if (tracksDict.Count >= 200 && !Console.IsOutputRedirected)
+                {
+                    Console.SetCursorPosition(0, Console.CursorTop);
+                    Console.Write($"Loaded: {tracks.Count}");
+                }
+
+                playlistItemsRequest.PageToken = playlistItemsResponse.NextPageToken;
+                if (playlistItemsRequest.PageToken == null || count >= max + offset)
+                    playlistItemsRequest = null;
+                else
+                    playlistItemsRequest.MaxResults = Math.Min(offset + max - count, 100);
+            }
+
+            Console.WriteLine();
+
+            return (playlistName, tracks);
+        }
+
+        // requestInfoIfNeeded=true is way too slow
+        public static async Task<Track> ParseTrackInfo(string title, string uploader, string id, int length, string desc = "", bool requestInfoIfNeeded = false)
+        {
+            (string title, string uploader, int length, string desc) info = ("", "", -1, "");
+            var track = new Track();
+            track.URI = id;
+
+            uploader = uploader.Replace("–", "-").Trim().RemoveConsecutiveWs();
+            title = title.Replace("–", "-").Replace(" -- ", " - ").Trim().RemoveConsecutiveWs();
+
+            var artist = uploader;
+            var trackTitle = title;
+
+            if (artist.EndsWith(" - Topic"))
+            {
+                artist = artist[..^7].Trim();
+                trackTitle = title;
+
+                if (artist == "Various Artists")
+                {
+                    if (desc.Length == 0 && requestInfoIfNeeded && id.Length > 0)
+                    {
+                        info = await GetVideoInfo(id);
+                        desc = info.desc;
+                    }
+
+                    if (desc.Length > 0)
+                    {
+                        var lines = desc.Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries);
+                        var dotLine = lines.FirstOrDefault(line => line.Contains(" · "));
+
+                        if (dotLine != null)
+                            artist = dotLine.Split(new[] { " · " }, StringSplitOptions.None)[1];
+                    }
+                }
+            }
+            else
+            {
+                track.ArtistMaybeWrong = !title.ContainsWithBoundary(artist, true) && !desc.ContainsWithBoundary(artist, true);
+
+                var split = title.Split(" - ", StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries);
+                if (split.Length == 2)
+                {
+                    artist = split[0];
+                    trackTitle = split[1];
+                    track.ArtistMaybeWrong = false;
+                }
+                else if (split.Length > 2)
+                {
+                    int index = Array.FindIndex(split, s => s.ContainsWithBoundary(artist, true));
+                    if (index != -1 && index < split.Length - 1)
+                    {
+                        artist = split[index];
+                        trackTitle = String.Join(" - ", split[(index + 1)..]);
+                        track.ArtistMaybeWrong = false;
+                    }
+                }
+
+                if (track.ArtistMaybeWrong && requestInfoIfNeeded && desc.Length == 0)
+                {
+                    info = await GetVideoInfo(id);
+                    track.ArtistMaybeWrong = !info.desc.ContainsWithBoundary(artist, true);
+                }
+            }
+
+            if (length <= 0 && id.Length > 0 && requestInfoIfNeeded)
+            {
+                if (info.length > 0)
+                    length = info.length;
+                else
+                {
+                    info = await GetVideoInfo(id);
+                    length = info.length;
+                }
+            }
+
+            track.Length = length;
+            track.Artist = artist;
+            track.Title = trackTitle;
+
+            return track;
+        }
+
+        public static async Task<(string title, string uploader, int length, string desc)> GetVideoInfo(string id)
+        {
+            (string title, string uploader, int length, string desc) o = ("", "", -1, "");
+
+            try
+            {
+                var vid = await youtube.Videos.GetAsync(id);
+                o.title = vid.Title;
+                o.uploader = vid.Author.ChannelTitle;
+                o.desc = vid.Description;
+                o.length = (int)vid.Duration.Value.TotalSeconds;
+            }
+            catch
+            {
+                if (apiKey.Length > 0)
+                {
+                    try
+                    {
+                        StartService();
+                        var videoRequest = youtubeService.Videos.List("contentDetails,snippet");
+                        videoRequest.Id = id;
+                        var videoResponse = videoRequest.Execute();
+
+                        o.title = videoResponse.Items[0].Snippet.Title;
+                        o.uploader = videoResponse.Items[0].Snippet.ChannelTitle;
+                        o.length = (int)XmlConvert.ToTimeSpan(videoResponse.Items[0].ContentDetails.Duration).TotalSeconds;
+                        o.desc = videoResponse.Items[0].Snippet.Description;
+                    }
+                    catch { }
+                }
+            }
+
+            return o;
+        }
+
+        public static void StartService()
+        {
+            if (youtubeService == null)
+            {
+                if (apiKey.Length == 0)
+                    throw new Exception("No API key");
+
+                youtubeService = new YouTubeService(new BaseClientService.Initializer()
+                {
+                    ApiKey = apiKey,
+                    ApplicationName = "slsk-batchdl"
+                });
+            }
+        }
+
+        public static void StopService()
+        {
+            youtubeService = null;
+        }
+
+        public static async Task<Dictionary<string, Track>> GetDictYtExplode(string url, int max = int.MaxValue, int offset = 0)
+        {
+            var youtube = new YoutubeClient();
+            var playlist = await youtube.Playlists.GetAsync(url);
+
+            var tracks = new Dictionary<string, Track>();
+            int count = 0;
+
+            await foreach (var video in youtube.Playlists.GetVideosAsync(playlist.Id))
+            {
+                if (count >= offset && count < offset + max)
+                {
+                    var title = video.Title;
+                    var uploader = video.Author.ChannelTitle;
+                    var ytId = video.Id.Value;
+                    var length = (int)video.Duration.Value.TotalSeconds;
+
+                    var track = await ParseTrackInfo(title, uploader, ytId, length);
+
+                    tracks[ytId] = track;
+                }
+
+                if (count++ >= offset + max)
+                    break;
+            }
+
+            return tracks;
+        }
+
+        public static async Task<string> GetPlaylistTitle(string url)
+        {
+            var youtube = new YoutubeClient();
+            var playlist = await youtube.Playlists.GetAsync(url);
+            return playlist.Title;
+        }
+
+        public static async Task<(string, List<Track>)> GetTracksYtExplode(string url, int max = int.MaxValue, int offset = 0)
+        {
+            var youtube = new YoutubeClient();
+            var playlist = await youtube.Playlists.GetAsync(url);
+
+            var playlistTitle = playlist.Title;
+            var tracks = new List<Track>();
+            int count = 0;
+
+            await foreach (var video in youtube.Playlists.GetVideosAsync(playlist.Id))
+            {
+                if (count >= offset && count < offset + max)
+                {
+                    var title = video.Title;
+                    var uploader = video.Author.ChannelTitle;
+                    var ytId = video.Id.Value;
+                    var length = (int)video.Duration.Value.TotalSeconds;
+
+                    var track = await ParseTrackInfo(title, uploader, ytId, length);
+
+                    tracks.Add(track);
+                }
+
+                if (count++ >= offset + max)
+                    break;
+            }
+
+            return (playlistTitle, tracks);
+        }
+
+
+        public static async Task<string> UrlToId(string url)
+        {
+            var playlist = await youtube.Playlists.GetAsync(url);
+            return playlist.Id.ToString();
+        }
+
+        public class YouTubeArchiveRetriever
+        {
+            private HttpClient _client;
+
+            public YouTubeArchiveRetriever()
+            {
+                _client = new HttpClient();
+                _client.Timeout = TimeSpan.FromSeconds(10);
+            }
+
+            public async Task<List<Track>> RetrieveDeleted(string url, bool printFailed = true)
+            {
+                var deletedVideoUrls = new BlockingCollection<string>();
+
+                int totalCount = 0;
+                int archivedCount = 0;
+                var tracks = new ConcurrentBag<Track>();
+                var noArchive = new ConcurrentBag<string>();
+                var failRetrieve = new ConcurrentBag<string>();
+
+                int workerCount = 4;
+                var workers = new List<Task>();
+                var consoleLock = new object();
+
+                void updateInfo()
+                {
+                    lock (consoleLock)
+                    {
+                        if (!Console.IsOutputRedirected)
+                        {
+                            string info = "Deleted metadata total/archived/retrieved: ";
+                            Console.SetCursorPosition(0, Console.CursorTop);
+                            Console.Write($"{info}{totalCount}/{archivedCount}/{tracks.Count}");
+                        }
+                    }
+                }
+
+                var process = new Process
+                {
+                    StartInfo = new ProcessStartInfo
+                    {
+                        FileName = "yt-dlp",
+                        Arguments = $"--ignore-no-formats-error --no-warn --match-filter \"!uploader\" --print webpage_url {url}",
+                        RedirectStandardOutput = true,
+                        UseShellExecute = false,
+                        CreateNoWindow = true,
+                    },
+                    EnableRaisingEvents = true
+                };
+                process.OutputDataReceived += (sender, e) =>
+                {
+                    if (!string.IsNullOrWhiteSpace(e.Data))
+                    {
+                        deletedVideoUrls.Add(e.Data);
+                        Interlocked.Increment(ref totalCount);
+                        updateInfo();
+                    }
+                };
+                process.Exited += (sender, e) =>
+                {
+                    deletedVideoUrls.CompleteAdding();
+                };
+
+                process.Start();
+                process.BeginOutputReadLine();
+
+                for (int i = 0; i < workerCount; i++)
+                {
+                    workers.Add(Task.Run(async () =>
+                    {
+                        foreach (var videoUrl in deletedVideoUrls.GetConsumingEnumerable())
+                        {
+                            var waybackUrls = await GetOldestArchiveUrls(videoUrl, limit: 2);
+                            if (waybackUrls != null && waybackUrls.Count > 0)
+                            {
+                                Interlocked.Increment(ref archivedCount);
+
+                                bool good = false;
+                                foreach (var waybackUrl in waybackUrls)
+                                {
+                                    var (title, uploader, duration) = await GetVideoDetails(waybackUrl);
+                                    if (!string.IsNullOrWhiteSpace(title))
+                                    {
+                                        var track = await ParseTrackInfo(title, uploader, waybackUrl, duration);
+                                        track.Other = $"{{\"t\":\"{title.Trim()}\",\"u\":\"{uploader.Trim()}\"}}";
+                                        tracks.Add(track);
+                                        good = true;
+                                        break;
+                                    }
+                                }
+
+                                if (!good)
+                                {
+                                    failRetrieve.Add(waybackUrls[0]);
+                                }
+                            }
+                            else
+                            {
+                                noArchive.Add(videoUrl);
+                            }
+
+                            updateInfo();
+                        }
+                    }));
+                }
+
+                await Task.WhenAll(workers);
+                process.WaitForExit();
+                deletedVideoUrls.CompleteAdding();
+                Console.WriteLine();
+
+                if (printFailed)
+                {
+                    if (archivedCount < totalCount)
+                    {
+                        Console.WriteLine("No archived version found for the following:");
+                        foreach (var x in noArchive)
+                            Console.WriteLine($"  {x}");
+                        Console.WriteLine();
+
+                    }
+                    if (tracks.Count < archivedCount)
+                    {
+                        Console.WriteLine("Failed to parse archived version for the following:");
+                        foreach (var x in failRetrieve)
+                            Console.WriteLine($"  {x}");
+                        Console.WriteLine();
+                    }
+                }
+
+                return tracks.ToList();
+            }
+
+            private async Task<List<string>> GetOldestArchiveUrls(string url, int limit)
+            {
+                var url2 = $"http://web.archive.org/cdx/search/cdx?url={url}&fl=timestamp,original&filter=statuscode:200&sort=timestamp:asc&limit={limit}";
+                HttpResponseMessage response = null;
+                for (int i = 0; i < 3; i++)
+                {
+                    try
+                    {
+                        response = await _client.GetAsync(url2);
+                        break;
+                    }
+                    catch { }
+                }
+                if (response == null) return null;
+
+                if (response.IsSuccessStatusCode)
+                {
+                    var content = await response.Content.ReadAsStringAsync();
+                    var lines = content.Split("\n").Where(line => !string.IsNullOrWhiteSpace(line)).ToList();
+                    if (lines.Count > 0)
+                    {
+                        for (int i = 0; i < lines.Count; i++)
+                        {
+                            var parts = lines[i].Split(" ");
+                            var timestamp = parts[0];
+                            var originalUrl = parts[1];
+                            lines[i] = $"http://web.archive.org/web/{timestamp}/{originalUrl}";
+                        }
+                        return lines;
+                    }
+                }
+                return null;
+            }
+
+            public async Task<(string title, string uploader, int duration)> GetVideoDetails(string url)
+            {
+                var web = new HtmlWeb();
+                var doc = await web.LoadFromWebAsync(url);
+
+                var titlePatterns = new[]
+                {
+                    "//h1[@id='video_title']",
+                    "//meta[@name='title']",
+                };
+
+                var usernamePatterns = new[]
+                {
+                    "//div[@id='userInfoDiv']/b/a",
+                    "//a[contains(@class, 'contributor')]",
+                    "//a[@id='watch-username']",
+                    "//a[contains(@class, 'author')]",
+                    "//div[@class='yt-user-info']/a",
+                    "//div[@id='upload-info']//yt-formatted-string/a",
+                    "//span[@itemprop='author']//link[@itemprop='name']",
+                    "//a[contains(@class, 'yt-user-name')]",
+                };
+
+                string getItem(string[] patterns)
+                {
+                    foreach (var pattern in patterns)
+                    {
+                        var node = doc.DocumentNode.SelectSingleNode(pattern);
+                        if (node != null)
+                        {
+                            var res = "";
+                            if (pattern.StartsWith("//meta") || pattern.Contains("@itemprop"))
+                                res = node.GetAttributeValue("content", "");
+                            else
+                                res = node.InnerText;
+                            if (!string.IsNullOrEmpty(res))
+                                return Utils.UnHtmlString(res);
+                        }
+                    }
+                    return "";
+                }
+
+                var title = getItem(titlePatterns);
+                if (string.IsNullOrEmpty(title))
+                {
+                    var pattern = @"document\.title\s*=\s*""(.+?) - YouTube"";";
+                    var match = Regex.Match(doc.Text, pattern);
+                    if (match.Success)
+                        title = match.Groups[1].Value;
+                }
+
+                var username = getItem(usernamePatterns);
+
+                int duration = -1;
+                var node = doc.DocumentNode.SelectSingleNode("//meta[@itemprop='duration']");
+                if (node != null)
+                {
+                    try
+                    {
+                        duration = (int)XmlConvert.ToTimeSpan(node.GetAttributeValue("content", "")).TotalSeconds;
+                    }
+                    catch { }
+                }
+
+                return (title, username, duration);
+            }
+        }
+
+        public static async Task<List<(int length, string id, string title)>> YtdlpSearch(Track track)
+        {
+            Process process = new Process();
+            ProcessStartInfo startInfo = new ProcessStartInfo();
+
+            startInfo.FileName = "yt-dlp";
+            string search = track.Artist.Length > 0 ? $"{track.Artist} - {track.Title}" : track.Title;
+            startInfo.Arguments = $"\"ytsearch3:{search}\" --print \"%(duration>%s)s === %(id)s === %(title)s\"";
+
+            startInfo.RedirectStandardOutput = true;
+            startInfo.RedirectStandardError = true;
+            startInfo.UseShellExecute = false;
+            process.StartInfo = startInfo;
+            process.OutputDataReceived += (sender, e) => { Console.WriteLine(e.Data); };
+            process.ErrorDataReceived += (sender, e) => { Console.WriteLine(e.Data); };
+
+            process.Start();
+
+            List<(int, string, string)> results = new List<(int, string, string)>();
+            string output;
+            Regex regex = new Regex(@"^(\d+) === ([\w-]+) === (.+)$");
+            while ((output = process.StandardOutput.ReadLine()) != null)
+            {
+                Match match = regex.Match(output);
+                if (match.Success)
+                {
+                    int seconds = int.Parse(match.Groups[1].Value);
+                    string id = match.Groups[2].Value;
+                    string title = match.Groups[3].Value;
+                    results.Add((seconds, id, title));
+                }
+            }
+
+            process.WaitForExit();
+            return results;
+        }
+
+        public static async Task<string> YtdlpDownload(string id, string savePathNoExt, string ytdlpArgument = "")
+        {
+            Process process = new Process();
+            ProcessStartInfo startInfo = new ProcessStartInfo();
+
+            if (ytdlpArgument.Length == 0)
+                ytdlpArgument = "\"{id}\" -f bestaudio/best -ci -o \"{savepath-noext}.%(ext)s\" -x";
+
+            startInfo.FileName = "yt-dlp";
+            startInfo.Arguments = ytdlpArgument
+                .Replace("{id}", id)
+                .Replace("{savepath}", savePathNoExt)
+                .Replace("{savepath-noext}", savePathNoExt)
+                .Replace("{savedir}", Path.GetDirectoryName(savePathNoExt));
+
+            startInfo.RedirectStandardOutput = true;
+            startInfo.RedirectStandardError = true;
+            startInfo.UseShellExecute = false;
+            process.StartInfo = startInfo;
+            //process.OutputDataReceived += (sender, e) => { Console.WriteLine(e.Data); };
+            //process.ErrorDataReceived += (sender, e) => { Console.WriteLine(e.Data); };
+
+            process.Start();
+            process.WaitForExit();
+
+            if (File.Exists(savePathNoExt + ".opus"))
+                return savePathNoExt + ".opus";
+
+            string parentDirectory = Path.GetDirectoryName(savePathNoExt);
+            string[] musicFiles = Directory.GetFiles(parentDirectory, "*", SearchOption.TopDirectoryOnly)
+                                            .Where(file => Utils.IsMusicFile(file))
+                                            .ToArray();
+            if (musicFiles.Length > 0)
+                return musicFiles[0];
+
+            return "";
+        }
+    }
+}
diff --git a/slsk-batchdl/Extractors/_Extractor.cs b/slsk-batchdl/Extractors/_Extractor.cs
new file mode 100644
index 0000000..f19672d
--- /dev/null
+++ b/slsk-batchdl/Extractors/_Extractor.cs
@@ -0,0 +1,36 @@
+using Enums;
+using Data;
+
+
+namespace Extractors
+{
+    public interface IExtractor
+    {
+        Task<TrackLists> GetTracks();
+        Task RemoveTrackFromSource(Track track) => Task.CompletedTask;
+    }
+
+    public static class ExtractorRegistry
+    {
+        static readonly List<(InputType, Func<string, bool>, Func<IExtractor>)> extractors = new()
+        {
+            (InputType.CSV,         CsvExtractor.InputMatches,      () => new CsvExtractor()),
+            (InputType.YouTube,     YouTubeExtractor.InputMatches,  () => new YouTubeExtractor()),
+            (InputType.Spotify,     SpotifyExtractor.InputMatches,  () => new SpotifyExtractor()),
+            (InputType.Bandcamp,    BandcampExtractor.InputMatches, () => new BandcampExtractor()),
+            (InputType.String,      StringExtractor.InputMatches,   () => new StringExtractor()),
+        };
+
+        public static (InputType, IExtractor?) GetMatchingExtractor(string input)
+        {
+            foreach ((var inputType, var inputMatches, var extractor) in extractors)
+            {
+                if (inputMatches(input))
+                {
+                    return (inputType, extractor());
+                }
+            }
+            return (InputType.None, null);
+        }
+    }
+}
diff --git a/slsk-batchdl/FileConditions.cs b/slsk-batchdl/FileConditions.cs
new file mode 100644
index 0000000..90176e6
--- /dev/null
+++ b/slsk-batchdl/FileConditions.cs
@@ -0,0 +1,296 @@
+using System.Text.RegularExpressions;
+
+using Data;
+
+using SearchResponse = Soulseek.SearchResponse;
+
+
+public class FileConditions
+{
+    public int LengthTolerance = -1;
+    public int MinBitrate = -1;
+    public int MaxBitrate = -1;
+    public int MinSampleRate = -1;
+    public int MaxSampleRate = -1;
+    public int MinBitDepth = -1;
+    public int MaxBitDepth = -1;
+    public bool StrictTitle = false;
+    public bool StrictArtist = false;
+    public bool StrictAlbum = false;
+    public string[] DangerWords = Array.Empty<string>();
+    public string[] Formats = Array.Empty<string>();
+    public string[] BannedUsers = Array.Empty<string>();
+    public string StrictStringRegexRemove = string.Empty;
+    public bool StrictStringDiacrRemove = true;
+    public bool AcceptNoLength = true;
+    public bool AcceptMissingProps = true;
+
+    public FileConditions() { }
+
+    public FileConditions(FileConditions other)
+    {
+        LengthTolerance = other.LengthTolerance;
+        MinBitrate = other.MinBitrate;
+        MaxBitrate = other.MaxBitrate;
+        MinSampleRate = other.MinSampleRate;
+        MaxSampleRate = other.MaxSampleRate;
+        AcceptNoLength = other.AcceptNoLength;
+        StrictArtist = other.StrictArtist;
+        StrictTitle = other.StrictTitle;
+        MinBitDepth = other.MinBitDepth;
+        MaxBitDepth = other.MaxBitDepth;
+        Formats = other.Formats.ToArray();
+        DangerWords = other.DangerWords.ToArray();
+        BannedUsers = other.BannedUsers.ToArray();
+    }
+
+    public override bool Equals(object obj)
+    {
+        if (obj is FileConditions other)
+        {
+            return LengthTolerance == other.LengthTolerance &&
+                   MinBitrate == other.MinBitrate &&
+                   MaxBitrate == other.MaxBitrate &&
+                   MinSampleRate == other.MinSampleRate &&
+                   MaxSampleRate == other.MaxSampleRate &&
+                   MinBitDepth == other.MinBitDepth &&
+                   MaxBitDepth == other.MaxBitDepth &&
+                   StrictTitle == other.StrictTitle &&
+                   StrictArtist == other.StrictArtist &&
+                   StrictAlbum == other.StrictAlbum &&
+                   StrictStringRegexRemove == other.StrictStringRegexRemove &&
+                   StrictStringDiacrRemove == other.StrictStringDiacrRemove &&
+                   AcceptNoLength == other.AcceptNoLength &&
+                   AcceptMissingProps == other.AcceptMissingProps &&
+                   Formats.SequenceEqual(other.Formats) &&
+                   DangerWords.SequenceEqual(other.DangerWords) &&
+                   BannedUsers.SequenceEqual(other.BannedUsers);
+        }
+        return false;
+    }
+
+    public void UnsetClientSpecificFields()
+    {
+        MinBitrate = -1;
+        MaxBitrate = -1;
+        MinSampleRate = -1;
+        MaxSampleRate = -1;
+        MinBitDepth = -1;
+        MaxBitDepth = -1;
+    }
+
+    public bool FileSatisfies(Soulseek.File file, Track track, SearchResponse? response)
+    {
+        return DangerWordSatisfies(file.Filename, track.Title, track.Artist) && FormatSatisfies(file.Filename)
+            && LengthToleranceSatisfies(file, track.Length) && BitrateSatisfies(file) && SampleRateSatisfies(file)
+            && StrictTitleSatisfies(file.Filename, track.Title) && StrictArtistSatisfies(file.Filename, track.Artist)
+            && StrictAlbumSatisfies(file.Filename, track.Album) && BannedUsersSatisfies(response) && BitDepthSatisfies(file);
+    }
+
+    public bool FileSatisfies(TagLib.File file, Track track, bool filenameChecks = false)
+    {
+        return DangerWordSatisfies(file.Name, track.Title, track.Artist) && FormatSatisfies(file.Name)
+            && LengthToleranceSatisfies(file, track.Length) && BitrateSatisfies(file) && SampleRateSatisfies(file)
+            && BitDepthSatisfies(file) && (!filenameChecks || StrictTitleSatisfies(file.Name, track.Title) 
+            && StrictArtistSatisfies(file.Name, track.Artist) && StrictAlbumSatisfies(file.Name, track.Album));
+    }
+
+    public bool FileSatisfies(SimpleFile file, Track track, bool filenameChecks = false)
+    {
+        return DangerWordSatisfies(file.Path, track.Title, track.Artist) && FormatSatisfies(file.Path)
+            && LengthToleranceSatisfies(file, track.Length) && BitrateSatisfies(file) && SampleRateSatisfies(file)
+            && BitDepthSatisfies(file) && (!filenameChecks || StrictTitleSatisfies(file.Path, track.Title)
+            && StrictArtistSatisfies(file.Path, track.Artist) && StrictAlbumSatisfies(file.Path, track.Album));
+    }
+
+    public bool DangerWordSatisfies(string fname, string tname, string aname)
+    {
+        if (tname.Length == 0)
+            return true;
+
+        fname = Utils.GetFileNameWithoutExtSlsk(fname).Replace(" — ", " - ");
+        tname = tname.Replace(" — ", " - ");
+
+        foreach (var word in DangerWords)
+        {
+            if (fname.ContainsIgnoreCase(word) ^ tname.ContainsIgnoreCase(word))
+            {
+                if (!(fname.Contains(" - ") && fname.ContainsIgnoreCase(word) && aname.ContainsIgnoreCase(word)))
+                {
+                    if (word == "mix")
+                        return fname.ContainsIgnoreCase("original mix") || tname.ContainsIgnoreCase("original mix");
+                    else
+                        return false;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    public bool StrictTitleSatisfies(string fname, string tname, bool noPath = true)
+    {
+        if (!StrictTitle || tname.Length == 0)
+            return true;
+
+        fname = noPath ? Utils.GetFileNameWithoutExtSlsk(fname) : fname;
+        return StrictString(fname, tname, StrictStringRegexRemove, StrictStringDiacrRemove, ignoreCase: true);
+    }
+
+    public bool StrictArtistSatisfies(string fname, string aname)
+    {
+        if (!StrictArtist || aname.Length == 0)
+            return true;
+
+        return StrictString(fname, aname, StrictStringRegexRemove, StrictStringDiacrRemove, ignoreCase: true, boundarySkipWs: false);
+    }
+
+    public bool StrictAlbumSatisfies(string fname, string alname)
+    {
+        if (!StrictAlbum || alname.Length == 0)
+            return true;
+
+        return StrictString(Utils.GetDirectoryNameSlsk(fname), alname, StrictStringRegexRemove, StrictStringDiacrRemove, ignoreCase: true);
+    }
+
+    public static string StrictStringPreprocess(string str, string regexRemove = "", bool diacrRemove = true)
+    {
+        str = str.Replace('_', ' ').ReplaceInvalidChars(' ', true, false);
+        str = regexRemove.Length > 0 ? Regex.Replace(str, regexRemove, "") : str;
+        str = diacrRemove ? str.RemoveDiacritics() : str;
+        str = str.Trim().RemoveConsecutiveWs();
+        return str;
+    }
+
+    public static bool StrictString(string fname, string tname, string regexRemove = "", bool diacrRemove = true, bool ignoreCase = true, bool boundarySkipWs = true)
+    {
+        if (tname.Length == 0)
+            return true;
+
+        fname = StrictStringPreprocess(fname, regexRemove, diacrRemove);
+        tname = StrictStringPreprocess(tname, regexRemove, diacrRemove);
+
+        if (boundarySkipWs)
+            return fname.ContainsWithBoundaryIgnoreWs(tname, ignoreCase, acceptLeftDigit: true);
+        else
+            return fname.ContainsWithBoundary(tname, ignoreCase);
+    }
+
+    public static bool BracketCheck(Track track, Track other)
+    {
+        string t1 = track.Title.RemoveFt().Replace('[', '(');
+        if (t1.Contains('('))
+            return true;
+
+        string t2 = other.Title.RemoveFt().Replace('[', '(');
+        if (!t2.Contains('('))
+            return true;
+
+        return false;
+    }
+
+    public bool FormatSatisfies(string fname)
+    {
+        if (Formats.Length == 0)
+            return true;
+
+        string ext = Path.GetExtension(fname).TrimStart('.').ToLower();
+        return ext.Length > 0 && Formats.Any(f => f == ext);
+    }
+
+    public bool LengthToleranceSatisfies(Soulseek.File file, int wantedLength) => LengthToleranceSatisfies(file.Length, wantedLength);
+    public bool LengthToleranceSatisfies(TagLib.File file, int wantedLength) => LengthToleranceSatisfies((int)file.Properties.Duration.TotalSeconds, wantedLength);
+    public bool LengthToleranceSatisfies(SimpleFile file, int wantedLength) => LengthToleranceSatisfies(file.Length, wantedLength);
+    public bool LengthToleranceSatisfies(int? length, int wantedLength)
+    {
+        if (LengthTolerance < 0 || wantedLength < 0)
+            return true;
+        if (length == null || length < 0)
+            return AcceptNoLength && AcceptMissingProps;
+        return Math.Abs((int)length - wantedLength) <= LengthTolerance;
+    }
+
+    public bool BitrateSatisfies(Soulseek.File file) => BitrateSatisfies(file.BitRate);
+    public bool BitrateSatisfies(TagLib.File file) => BitrateSatisfies(file.Properties.AudioBitrate);
+    public bool BitrateSatisfies(SimpleFile file) => BitrateSatisfies(file.Bitrate);
+    public bool BitrateSatisfies(int? bitrate)
+    {
+        return BoundCheck(bitrate, MinBitrate, MaxBitrate);
+    }
+
+    public bool SampleRateSatisfies(Soulseek.File file) => SampleRateSatisfies(file.SampleRate);
+    public bool SampleRateSatisfies(TagLib.File file) => SampleRateSatisfies(file.Properties.AudioSampleRate);
+    public bool SampleRateSatisfies(SimpleFile file) => SampleRateSatisfies(file.Samplerate);
+    public bool SampleRateSatisfies(int? sampleRate)
+    {
+        return BoundCheck(sampleRate, MinSampleRate, MaxSampleRate);
+    }
+
+    public bool BitDepthSatisfies(Soulseek.File file) => BitDepthSatisfies(file.BitDepth);
+    public bool BitDepthSatisfies(TagLib.File file) => BitDepthSatisfies(file.Properties.BitsPerSample);
+    public bool BitDepthSatisfies(SimpleFile file) => BitDepthSatisfies(file.Bitdepth);
+    public bool BitDepthSatisfies(int? bitdepth)
+    {
+        return BoundCheck(bitdepth, MinBitDepth, MaxBitDepth);
+    }
+
+    public bool BoundCheck(int? num, int min, int max)
+    {
+        if (max < 0 && min < 0)
+            return true;
+        if (num == null || num < 0)
+            return AcceptMissingProps;
+        if (num < min || max != -1 && num > max)
+            return false;
+        return true;
+    }
+
+    public bool BannedUsersSatisfies(SearchResponse? response)
+    {
+        return response == null || !BannedUsers.Any(x => x == response.Username);
+    }
+
+    public string GetNotSatisfiedName(Soulseek.File file, Track track, SearchResponse? response)
+    {
+        if (!DangerWordSatisfies(file.Filename, track.Title, track.Artist))
+            return "DangerWord fails";
+        if (!FormatSatisfies(file.Filename))
+            return "Format fails";
+        if (!LengthToleranceSatisfies(file, track.Length))
+            return "Length fails";
+        if (!BitrateSatisfies(file))
+            return "Bitrate fails";
+        if (!SampleRateSatisfies(file))
+            return "SampleRate fails";
+        if (!StrictTitleSatisfies(file.Filename, track.Title))
+            return "StrictTitle fails";
+        if (!StrictArtistSatisfies(file.Filename, track.Artist))
+            return "StrictArtist fails";
+        if (!BitDepthSatisfies(file))
+            return "BitDepth fails";
+        if (!BannedUsersSatisfies(response))
+            return "BannedUsers fails";
+        return "Satisfied";
+    }
+
+    public string GetNotSatisfiedName(TagLib.File file, Track track)
+    {
+        if (!DangerWordSatisfies(file.Name, track.Title, track.Artist))
+            return "DangerWord fails";
+        if (!FormatSatisfies(file.Name))
+            return "Format fails";
+        if (!LengthToleranceSatisfies(file, track.Length))
+            return "Length fails";
+        if (!BitrateSatisfies(file))
+            return "Bitrate fails";
+        if (!SampleRateSatisfies(file))
+            return "SampleRate fails";
+        if (!StrictTitleSatisfies(file.Name, track.Title))
+            return "StrictTitle fails";
+        if (!StrictArtistSatisfies(file.Name, track.Artist))
+            return "StrictArtist fails";
+        if (!BitDepthSatisfies(file))
+            return "BitDepth fails";
+        return "Satisfied";
+    }
+}
diff --git a/slsk-batchdl/Help.cs b/slsk-batchdl/Help.cs
new file mode 100644
index 0000000..dafa1d7
--- /dev/null
+++ b/slsk-batchdl/Help.cs
@@ -0,0 +1,490 @@
+
+// undocumented options
+// --login, --random-login, --no-modify-share-count, --unknown-error-retries
+// --invalid-replace-str, --cond, --pref, --danger-words, --pref-danger-words, --strict-title, --strict-artist, --strict-album
+// --fast-search-delay, --fast-search-min-up-speed
+// --min-album-track-count, --max-album-track-count, --extract-max-track-count, --extract-min-track-count 
+
+public static class Help
+{
+    const string helpText = @"
+    Usage: sldl <input> [OPTIONS]
+
+      Required Arguments 
+        <input>                        A url, search string, or path to a local CSV file.
+                                       Run --help ""input"" to view the accepted inputs. 
+                                       Can also be passed with -i, --input <input>            
+        --user <username>              Soulseek username
+        --pass <password>              Soulseek password
+
+      General Options
+        -p, --path <path>              Download directory
+        -f, --folder <name>            Subfolder name. Set to '.' to output directly to --path
+        --input-type <type>            Force set input type, [csv|youtube|spotify|bandcamp|string]
+        --name-format <format>         Name format for downloaded tracks. See --help name-format
+          
+        -n, --number <maxtracks>       Download the first n tracks of a playlist
+        -o, --offset <offset>          Skip a specified number of tracks
+        -r, --reverse                  Download tracks in reverse order
+        -c, --config <path>            Set config file location. Set to 'none' to ignore config
+        --profile <name>               Configuration profile to use. See --help ""config"".
+        --concurrent-downloads <num>   Max concurrent downloads (default: 2)
+        --m3u <option>                 Create an m3u8 playlist file in the output directory
+                                       'none' (default for single inputs): Do not create 
+                                       'index' (default): Write a line indexing all downloaded 
+                                       files, required for skip-not-found or skip-existing=m3u
+                                       'all': Write the index and a list of paths and fails
+            
+        -s, --skip-existing            Skip if a track matching file conditions is found in the
+                                       output folder or your music library (if provided)
+        --skip-mode <mode>             [name|tag|m3u|name-cond|tag-cond|m3u-cond]
+                                       See --help ""skip-existing"".
+        --music-dir <path>             Specify to also skip downloading tracks found in a music
+                                       library. Use with --skip-existing
+        --skip-not-found               Skip searching for tracks that weren't found on Soulseek
+                                       during the last run. Fails are read from the m3u file.
+          
+        --display-mode <option>        Changes how searches and downloads are displayed:
+                                       'single' (default): Show transfer state and percentage
+                                       'double': Transfer state and a large progress bar 
+                                       'simple': No download bars or changing percentages
+        --print <option>               Print tracks or search results instead of downloading:
+                                       'tracks': Print all tracks to be downloaded
+                                       'tracks-full': Print extended information about all tracks
+                                       'results': Print search results satisfying file conditions
+                                       'results-full': Print search results including full paths
+        --debug                        Print extra debug info
+          
+        --listen-port <port>           Port for incoming connections (default: 49998)
+        --on-complete <command>        Run a specified command whenever a file is downloaded.
+                                       Available placeholders: {path} (local save path), {title},
+                                       {artist},{album},{uri},{length},{failure-reason},{state}.
+                                       Prepend a state number to only download in specific cases:
+                                       1:, 2:, 3:, 4: for the Downloaded, Failed, Exists, and
+                                       NotFoundLastTime states respectively. 
+                                       E.g: '1:<cmd>' will only run the command if the file is
+                                       downloaded successfully.
+          
+      Searching
+        --fast-search                  Begin downloading as soon as a file satisfying the preferred
+                                       conditions is found. Higher chance to download wrong files.
+        --remove-ft                    Remove 'feat.' and everything after before searching
+        --no-remove-special-chars      Do not remove special characters before searching
+        --remove-brackets              Remove square brackets and their contents before searching
+        --regex <regex>                Remove a regexp from all track titles and artist names.
+                                       Optionally specify a replacement regex after a semicolon.
+                                       Add 'T:', 'A:' or 'L:' at the start to only apply this to
+                                       the track title, artist, or album respectively.
+        --artist-maybe-wrong           Performs an additional search without the artist name.
+                                       Useful for sources like SoundCloud where the ""artist""
+                                       could just be an uploader. Note that when downloading a
+                                       YouTube playlist via url, this option is set automatically
+                                       on a per-track basis, so it is best kept off in that case.
+        -d, --desperate                Tries harder to find the desired track by searching for the
+                                       artist/album/title only, then filtering. (slower search)
+        --fails-to-downrank <num>      Number of fails to downrank a user's uploads (default: 1)
+        --fails-to-ignore <num>        Number of fails to ban/ignore a user's uploads (default: 2)
+          
+        --yt-dlp                       Use yt-dlp to download tracks that weren't found on
+                                       Soulseek. yt-dlp must be available from the command line.
+        --yt-dlp-argument <str>        The command line arguments when running yt-dlp. Default:
+                                       ""{id}"" -f bestaudio/best -cix -o ""{savepath}.%(ext)s""
+                                       Available vars are: {id}, {savedir}, {savepath} (w/o ext).
+                                       Note that with -x, yt-dlp will download webms in case
+                                       ffmpeg is unavailable.
+          
+        --search-timeout <ms>          Max search time in ms (default: 6000)
+        --max-stale-time <ms>          Max download time without progress in ms (default: 50000)
+        --searches-per-time <num>      Max searches per time interval. Higher values may cause
+                                       30-minute bans, see --help ""search"". (default: 34)
+        --searches-renew-time <sec>    Controls how often available searches are replenished.
+                                       See --help ""search"". (default: 220)
+          
+      Spotify
+        --spotify-id <id>              spotify client ID
+        --spotify-secret <secret>      spotify client secret
+        --remove-from-source           Remove downloaded tracks from source playlist
+          
+      YouTube
+        --youtube-key <key>            Youtube data API key
+        --get-deleted                  Attempt to retrieve titles of deleted videos from wayback
+                                       machine. Requires yt-dlp.
+        --deleted-only                 Only retrieve & download deleted music.
+          
+      CSV Files
+        --artist-col                   Artist column name
+        --title-col                    Track title column name
+        --album-col                    Album column name
+        --length-col                   Track length column name
+        --album-track-count-col        Album track count column name (sets --album-track-count)
+        --yt-desc-col                  Youtube description column (improves --yt-parse)
+        --yt-id-col                    Youtube video id column (improves --yt-parse)
+            
+        --time-format <format>         Time format in Length column of the csv file (e.g h:m:s.ms
+                                       for durations like 1:04:35.123). Default: s
+        --yt-parse                     Enable if the CSV contains YouTube video titles and channel
+                                       names; attempt to parse them into title and artist names.
+        --remove-from-source           Remove downloaded tracks from source CSV file 
+          
+      File Conditions
+        --format <formats>             Accepted file format(s), comma-separated, without periods
+        --length-tol <sec>             Length tolerance in seconds
+        --min-bitrate <rate>           Minimum file bitrate
+        --max-bitrate <rate>           Maximum file bitrate
+        --min-samplerate <rate>        Minimum file sample rate
+        --max-samplerate <rate>        Maximum file sample rate
+        --min-bitdepth <depth>         Minimum bit depth
+        --max-bitdepth <depth>         Maximum bit depth
+        --banned-users <list>          Comma-separated list of users to ignore
+          
+        --pref-format <formats>        Preferred file format(s), comma-separated (default: mp3)
+        --pref-length-tol <sec>        Preferred length tolerance in seconds (default: 3)
+        --pref-min-bitrate <rate>      Preferred minimum bitrate (default: 200)
+        --pref-max-bitrate <rate>      Preferred maximum bitrate (default: 2500)
+        --pref-min-samplerate <rate>   Preferred minimum sample rate
+        --pref-max-samplerate <rate>   Preferred maximum sample rate (default: 48000)
+        --pref-min-bitdepth <depth>    Preferred minimum bit depth
+        --pref-max-bitdepth <depth>    Preferred maximum bit depth
+        --pref-banned-users <list>     Comma-separated list of users to downrank
+          
+        --strict-conditions            Skip files with missing properties instead of accepting by
+                                       default; if --min-bitrate is set, ignores any files with
+                                       unknown bitrate.
+          
+      Album Download
+        -a, --album                    Album download mode
+        -t, --interactive              Allows to select the wanted folder and images
+        --album-track-count <num>      Specify the exact number of tracks in the album. Add a + or
+                                       - for inequalities, e.g '5+' for five or more tracks.
+        --album-ignore-fails           Do not skip to the next source and do not delete all 
+                                       successfully downloaded files if one of the files in the 
+                                       folder fails to download
+        --album-art <option>           Retrieve additional images after downloading the album:
+                                       'default': No additional images
+                                       'largest': Download from the folder with the largest image
+                                       'most': Download from the folder containing the most images
+                                       'most-largest': Do most, then largest
+        --album-art-only               Only download album art for the provided album
+        --no-browse-folder             Do not automatically browse user shares to get all files in
+                                       in the folder
+          
+      Aggregate Download
+        -g, --aggregate                Aggregate download mode: Find and download all distinct 
+                                       songs associated with the provided artist, album, or title.
+        --min-users-aggregate <num>    Minimum number of users sharing a track or album for it to
+                                       be downloaded in aggregate mode. (Default: 2)
+        --relax-filtering              Slightly relax file filtering in aggregate mode to include
+                                       more results
+
+      Help
+        -h, --help [option]            [all|input|download-modes|search|name-format|
+                                       file-conditions|skip-existing|config]
+          
+      Notes 
+        Acronyms of two- and --three-word-flags are also accepted, e.g. --twf. If the option
+        contains the word 'max' then the m should be uppercase. 'bitrate', 'sameplerate' and 
+        'bitdepth' should be all treated as two separate words, e.g --Mbr for --max-bitrate.
+
+        Flags can be explicitly disabled by setting them to false, e.g '--interactive false'
+    ";
+
+    const string inputHelp = @"
+    Input types
+
+      The input type is usually determined automatically. To force a specific input type, set
+      --input-type [spotify|youtube|csv|string|bandcamp]. The following input types are available:
+            
+      CSV file            
+        Path to a local CSV file: Use a csv file containing track info of the songs to download. 
+        The names of the columns should be Artist, Title, Album, Length, although alternative names 
+        are usually detected as well. Only the title or album column is required, but extra info may 
+        improve search results. Every row that does not have a title column text will be treated as an
+        album download.
+            
+      YouTube 
+        A playlist url: Download songs from a youtube playlist.
+        The default method to retrieve playlists doesn't always return all videos, especially not 
+        the ones which are unavailable. To get all video titles, you can use the official API by 
+        providing a key with --youtube-key. Get it here https://console.cloud.google.com. Create a 
+        new project, click ""Enable Api"" and search for ""youtube data"", then follow the prompts. 
+        
+        Tip: For playlists containing music videos, it may be better to remove all text in parentheses 
+        (to remove (Lyrics), (Official), etc) and disable song duration checking: 
+        --regex ""[\[\(].*?[\]\)]"" --pref-length-tol -1     
+
+      Spotify
+        A playlist/album url or 'spotify-likes': Download a spotify playlist, album, or your 
+        liked songs. --spotify-id and --spotify-secret are required in addition when downloading
+        a private playlist or liked music.
+        The id and secret can be obtained at https://developer.spotify.com/dashboard/applications. 
+        Create an app and add http://localhost:48721/callback as a redirect url in its settings.
+
+      Bandcamp 
+        An bandcamp url: Download a single track, and album, or an artist's entire discography. 
+        Extracts the artist name, album name and sets --album-track-count=""n+"", where n is the 
+        number of visible tracks on the bandcamp page.
+
+      Search string
+        Name of the track, album, or artist to search for: Can either be any typical search string 
+        (like what you would enter into the soulseek search bar), or a comma-separated list of
+        properties like 'title=Song Name, artist=Artist Name, length=215'. 
+
+        The following properties are allowed: 
+          title
+          artist
+          album
+          length (in seconds)
+          artist-maybe-wrong 
+
+        Example inputs and their interpretations:
+          Input String                            | Artist   | Title    | Album    | Length
+          ---------------------------------------------------------------------------------
+          'Foo Bar'   (without any hyphens)       |          | Foo Bar  |          |
+          'Foo - Bar'                             | Foo      | Bar      |          |
+          'Foo - Bar' (with --album enabled)      | Foo      |          | Bar      |
+          'Artist - Title, length=42'             | Artist   | Title    |          | 42
+          'artist=AR, title=T, album=AL'          | AR       | T        | AL       |
+    ";
+
+    const string downloadModesHelp = @"
+    Download modes
+          
+      Normal
+        The program will download a single file for every input entry.
+
+      Album
+        The program will search for the album and download an entire folder including non-audio
+        files. Activated when the input is a link to a spotify or bandcamp album, when the input 
+        string or csv row has no track title, or when -a/--album is enabled.
+        
+      Aggregate
+        With -g/--aggregate, the program will first perform an ordinary search for the input, then
+        attempt to group the results into distinct songs and download one of each kind. A common use
+        case is finding all remixes of a song or printing all songs by an artist that are not your 
+        music dir.
+        Two files are considered equal if their inferred track title and artist name are equal 
+        (ignoring case and some special characters), and their lengths are within --length-tol of each
+        other.
+        Note that this mode is not 100% reliable, which is why --min-users-aggregate is set to 2 by
+        default, i.e. any song that is shared by only one peer will be ignored. Enable --relax-filtering
+        to make the file filtering less aggressive.
+
+      Album Aggregate
+        Activated when --album and --aggregate are enabled, in this mode sldl searches for the query
+        and groups results into distinct albums. Two folders are considered same if they have the
+        same number of audio files, and the durations of the files are within --length-tol of each 
+        other (or within 3 seconds if length-tol is not configured). If both folders have exactly one
+        audio file with similar lengths, also checks if the inferred title and artist name coincide.
+        More reliable than normal aggregate due to much simpler grouping logic.
+        Note that --min-users-aggregate is 2 by default, which means that folders shared by only one
+        peer are ignored.
+    ";
+
+    const string searchHelp = @"
+    Searching
+
+      Soulseek's rate limits
+        The server will ban you for 30 minutes if too many searches are performed within a short 
+        timespan. The program has a search limiter which can be adjusted with --searches-per-time 
+        and --searches-renew-time (when the limit is reached, the status of the downloads will be 
+        ""Waiting""). By default it is configured to allow up to 34 searches every 220 seconds. 
+        The default values were determined through experimentation, so they may be incorrect.
+
+      Quality vs Speed
+        The following options will make it go faster, but may decrease search result quality or cause
+        instability:
+          --fast-search skips waiting until the search completes and downloads as soon as a file 
+            matching the preferred conditions is found
+          --concurrent-downloads - set it to 4 or more
+          --max-stale-time is set to 50 seconds by default, so it will wait a long time before giving 
+            up on a file
+          --searches-per-time increase at the risk of bans.
+        
+      Quality vs Quantity
+        The options --strict-title, --strict-artist and --strict-album will filter any file that 
+        does not contain the title/artist/album in the filename (ignoring case, bounded by boundary 
+        chars). 
+        Another way to prevent false downloads is to set --length-tol to 3 or less to make it ignore 
+        any songs that differ from the input by more than 3 seconds. However, all 4 options are already 
+        enabled as 'preferred' conditions by default, meaning that such files will only be downloaded 
+        as a last resort anyways. Hence it is only recommended to enable them if you need to minimize
+        false downloads as much as possible.
+    ";
+
+    const string fileConditionsHelp = @"
+    File conditions
+
+      Files not satisfying the required conditions will not be downloaded. Files satisfying pref- 
+      conditions will be preferred; setting --pref-format ""flac,wav"" will make it download lossless 
+      files if available, and only download lossy files if there's nothing else. 
+        
+      There are no default required conditions. The default preferred conditions are:
+
+        format = mp3
+        length-tol = 3
+        min-bitrate = 200
+        max-bitrate = 2500
+        max-samplerate = 48000
+        strict-title = true
+        strict-album = true
+        accept-no-length = false
+
+      sldl will therefore prefer mp3 files with bitrate between 200 and 2500 kbps, and whose length
+      differs from the supplied length by no more than 3 seconds. It will also prefer files whose
+      paths contain the supplied artist and album (ignoring case, and bounded by boundary characters)
+      and which have a non-null length. Changing the last three preferred conditions is not recommended.
+        
+      Important note
+        Some info may be unavailable depending on the client used by the peer. For example, the standard 
+        Soulseek client does not share the file bitrate. If (e.g) --min-bitrate is set, then sldl will 
+        still accept any file with unknown bitrate. You can configure it to reject all files where one 
+        or more of the checked properties is null (unknown) by enabling --strict-conditions. 
+        As a consequence, if --min-bitrate is also set then any files shared by users with the default 
+        client will be ignored. Also note that the default preferred conditions will already affect
+        ranking with this option due to the bitrate and samplerate checks.
+        
+      Conditions can also be supplied as a semicolon-delimited string with --cond and --pref, e.g 
+      --cond ""br>=320;f=mp3,ogg;sr<96000""
+    ";
+
+    const string nameFormatHelp = @"
+    Name format
+      
+      Variables enclosed in {} will be replaced by the corresponding file tag value.         
+      Name format supports subdirectories as well as conditional expressions like {tag1|tag2} - If
+      tag1 is null, use tag2. String literals enclosed in parentheses are ignored in the null check. 
+        
+      Examples:
+        ""{artist} - {title}""
+            Always name it 'Artist - Title'. Because some files on Soulseek are untagged, the 
+            following is generally preferred:
+        ""{artist( - )title|filename}""
+            If artist and title are not null, name it 'Artist - Title', otherwise use the original 
+            filename.
+        
+      Available variables:
+        artist                          First artist (from the file tags)
+        sartist                         Source artist (as on CSV/Spotify/YouTube/etc)
+        artists                         Artists, joined with '&'
+        albumartist                     First album artist
+        albumartists                    Album artists, joined with '&'
+        title                           Track title
+        stitle                          Source track title
+        album                           Album name
+        salbum                          Source album name
+        year                            Track year or date
+        track                           Track number
+        disc                            Disc number
+        filename                        Soulseek filename without extension
+        foldername                      Default sldl folder name
+        extractor                       Name of the extractor used (CSV/Spotify/YouTube/etc)
+    ";
+
+    const string skipExistingHelp = @"
+    Skip existing
+
+      sldl can skip files that exist in the download directory or a specified directory configured with
+      --music-dir.
+      The following modes are available for --skip-mode:
+
+      m3u
+        Default when checking in the output directory.  
+        Checks whether the output m3u file contains the track in the '#SLDL' line. Does not check if
+        the audio file exists or satisfies the file conditions, use m3u-cond for that.
+
+      name
+        Compares filenames to the track title and artist name to determine if a track already exists.
+        Specifically, a track will be skipped if there exists a file whose name contains the title
+        and whose full path contains the artist name.
+
+      tag
+        Compares file tags to the track title and artist name. A track is skipped if there is a file 
+        whose artist tag contains the track artist and whose title tag equals the track title 
+        (ignoring case and ws). Slower than name mode as it needs to read all file tags.
+
+      m3u-cond, name-cond, tag-cond
+        Default for checking in --music-dir: name-cond. 
+        Same as the above modes but also checks whether the found file satisfies necessary conditions.
+        Equivalent to the above modes if no necessary conditions have been specified (except m3u-cond
+        which always checks if the file exists). May be slower and use a lot of memory for large 
+        libraries.
+    ";
+
+    const string configHelp = @"
+    Configuration
+      Config Location:
+        sldl will look for a file named sldl.conf in the following locations:
+
+          ~/AppData/Roaming/sldl/sldl.conf
+          ~/.config/sldl/sldl.conf
+
+        as well as in the directory of the executable.
+        
+      Syntax:
+        Example config file:
+        
+          username = your-username
+          password = your-password
+          pref-format = flac
+          fast-search = true
+        
+        Lines starting with hashtags (#) will be ignored. Tildes in paths are expanded as the user 
+        directory.
+
+      Configuration profiles:
+        Profiles are supported:
+
+          [lossless]
+          pref-format = flac,wav
+
+        To activate the above profile, run --profile ""lossless"". To list all available profiles,
+        run --profile ""help"".
+        Profiles can be activated automatically based on a few simple conditions:
+        
+          [no-stale]
+          profile-cond = interactive && download-mode == ""album""
+          max-stale-time = 999999
+          # album downloads will never be automatically cancelled in interactive mode
+            
+          [youtube]
+          profile-cond = input-type == ""youtube""
+          path = ~/downloads/sldl-youtube
+          # download to another location for youtube
+
+        The following operators are supported: &&, ||, ==, !=, ! (negation for bools).
+        The following variables are available for use in profile-cond:
+
+          input-type        ( = ""youtube""|""csv""|""string""|""bandcamp""|""spotify"")
+          download-mode     ( = ""normal""|""aggregate""|""album""|""album-aggregate"")
+          interactive       (bool)
+    ";
+
+    public static void PrintHelp(string option = "")
+    {
+        string text = helpText;
+
+        var dict = new Dictionary<string, string>() 
+        {
+            { "input", inputHelp },
+            { "download-modes", downloadModesHelp },
+            { "search", searchHelp },
+            { "file-conditions", fileConditionsHelp },
+            { "name-format", nameFormatHelp },
+            { "skip-existing", skipExistingHelp },
+            { "config", configHelp },
+        };
+
+        if (dict.ContainsKey(option))
+            text = dict[option];
+        else if (option == "all")
+            text = $"{helpText}\n{string.Join('\n', dict.Values)}";
+        else if (option.Length > 0)
+            Console.WriteLine($"Unrecognized help option '{option}'");
+
+        var lines = text.Split('\n').Skip(1);
+        int minIndent = lines.Where(line => line.Trim().Length > 0).Min(line => line.TakeWhile(char.IsWhiteSpace).Count());
+        text = string.Join("\n", lines.Select(line => line.Length > minIndent ? line[minIndent..] : line));
+        Console.WriteLine(text);
+    }
+}
+
diff --git a/slsk-batchdl/M3uEditor.cs b/slsk-batchdl/M3uEditor.cs
new file mode 100644
index 0000000..5d34aa5
--- /dev/null
+++ b/slsk-batchdl/M3uEditor.cs
@@ -0,0 +1,299 @@
+using Data;
+using Enums;
+using System.Text;
+
+
+public class M3uEditor
+{
+    List<string> lines;
+    TrackLists trackLists;
+    string path;
+    string parent;
+    int offset = 0;
+    M3uOption option = M3uOption.Index;
+    bool needFirstUpdate = false;
+    Dictionary<string, Track> previousRunTracks = new(); // {track.ToKey(), track }
+
+    public M3uEditor(string m3uPath, TrackLists trackLists, M3uOption option, int offset = 0)
+    {
+        this.trackLists = trackLists;
+        this.offset = offset;
+        this.option = option;
+        this.path = Path.GetFullPath(m3uPath);
+        this.parent = Path.GetDirectoryName(path);
+        this.lines = ReadAllLines().ToList();
+        this.needFirstUpdate = option == M3uOption.All;
+
+        LoadPreviousResults();
+    }
+
+    private void LoadPreviousResults() // #SLDL:path,artist,album,title,length(int),state(int),failurereason(int); ... ; ...
+    {
+        if (lines.Count == 0 || !lines[0].StartsWith("#SLDL:"))
+            return;
+
+        string sldlLine = lines[0]["#SLDL:".Length..];
+        var currentItem = new StringBuilder();
+        bool inQuotes = false;
+
+        lines = lines.Skip(1).ToList();
+
+        for (int k = 0; k < sldlLine.Length; k++)
+        {
+            var track = new Track();
+            int field = 0;
+            for (int i = k; i < sldlLine.Length; i++)
+            {
+                char c = sldlLine[i];
+
+                if (c == '"' && (i == k || sldlLine[i - 1] != '\\'))
+                {
+                    if (inQuotes && i + 1 < sldlLine.Length && sldlLine[i + 1] == '"')
+                    {
+                        currentItem.Append('"');
+                        i++;
+                    }
+                    else
+                    {
+                        inQuotes = !inQuotes;
+                    }
+                }
+                else if (field <= 5 && c == ',' && !inQuotes)
+                {
+                    var x = currentItem.ToString();
+
+                    if (field == 0)
+                    {
+                        if (x.StartsWith("./"))
+                            x = Path.Join(parent, x[2..]);
+                        track.DownloadPath = x;
+                    }
+                    else if (field == 1)
+                        track.Artist = x;
+                    else if (field == 2)
+                        track.Album = x;
+                    else if (field == 3)
+                        track.Title = x;
+                    else if (field == 4)
+                        track.Length = int.Parse(x);
+                    else if (field == 5)
+                        track.State = (TrackState)int.Parse(x);
+
+                    currentItem.Clear();
+                    field++;
+                }
+                else if (field == 6 && c == ';')
+                {
+                    track.FailureReason = (FailureReason)int.Parse(currentItem.ToString());
+                    currentItem.Clear();
+                    k = i;
+                    break;
+                }
+                else
+                {
+                    currentItem.Append(c);
+                }
+            }
+            previousRunTracks[track.ToKey()] = track;
+        }
+    }
+
+    public void Update()
+    {
+        if (option == M3uOption.None)
+            return;
+
+        lock (trackLists)
+        {
+            bool needUpdate = false;
+            int index = 1 + offset;
+
+            void updateLine(string newLine)
+            {
+                while (index >= lines.Count) lines.Add("");
+                lines[index] = newLine;
+            }
+
+            foreach (var tle in trackLists.lists)
+            {
+                if (tle.type != ListType.Normal)
+                {
+                    continue;
+                }
+                //if (option == M3uOption.All && source.State == TrackState.Failed)
+                //{
+                //    string reason = source.FailureReason.ToString();
+                //    updateLine(TrackToLine(source, reason));
+                //    index++;
+                //}
+                else
+                {
+                    for (int k = 0; k < tle.list.Count; k++)
+                    {
+                        for (int j = 0; j < tle.list[k].Count; j++)
+                        {
+                            var track = tle.list[k][j];
+
+                            if (track.IsNotAudio || track.State == TrackState.Initial)
+                                continue;
+
+                            string trackKey = track.ToKey();
+                            previousRunTracks.TryGetValue(trackKey, out Track? indexTrack);
+
+                            if (!needUpdate)
+                            {
+                                needUpdate |= indexTrack == null
+                                    || indexTrack.State != track.State
+                                    || indexTrack.FailureReason != track.FailureReason
+                                    || indexTrack.DownloadPath != track.DownloadPath;
+                            }
+
+                            previousRunTracks[trackKey] = track;
+
+                            if (option == M3uOption.All)
+                            {
+                                if (track.State != TrackState.AlreadyExists || k == 0)
+                                {
+                                    string? reason = track.FailureReason != FailureReason.None ? track.FailureReason.ToString() : null;
+                                    if (reason == null && track.State == TrackState.NotFoundLastTime)
+                                        reason = nameof(FailureReason.NoSuitableFileFound);
+
+                                    updateLine(TrackToLine(track, reason));
+                                    if (tle.type != ListType.Normal)
+                                        index++;
+                                }
+                            }
+
+                            if (tle.type == ListType.Normal)
+                                index++;
+                        }
+                    }
+                }
+            }
+
+            if (needUpdate || needFirstUpdate)
+            {
+                needFirstUpdate = false;
+                WriteAllLines();
+            }
+        }
+    }
+
+    private void WriteAllLines()
+    {
+        if (!Directory.Exists(parent))
+            Directory.CreateDirectory(parent);
+
+        using var fileStream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.Write, FileShare.ReadWrite);
+        using var writer = new StreamWriter(fileStream);
+        WriteSldlLine(writer);
+        foreach (var line in lines)
+        {
+            writer.Write(line);
+            writer.Write('\n');
+        }
+    }
+
+    private void WriteSldlLine(StreamWriter writer)  // #SLDL:path,artist,album,title,length(int),state(int),failurereason(int); ... ; ...
+    {
+        void writeCsvLine(string[] items)
+        {
+            bool comma = false;
+            foreach (var item in items)
+            {
+                if (comma)
+                    writer.Write(',');
+
+                if (item.Contains(',') || item.Contains('\"'))
+                {
+                    writer.Write('"');
+                    writer.Write(item.Replace("\"", "\"\""));
+                    writer.Write('"');
+                }
+                else
+                {
+                    writer.Write(item);
+                }
+
+                comma = true;
+            }
+        }
+
+        writer.Write("#SLDL:");
+
+        foreach (var val in previousRunTracks.Values)
+        {
+            string p = val.DownloadPath;
+            if (p.StartsWith(parent))
+                p = "./" + Path.GetRelativePath(parent, p); // prepend ./ for LoadPreviousResults to recognize that a rel. path is used
+
+            var items = new string[] 
+            { 
+                p,
+                val.Artist,
+                val.Album,
+                val.Title,
+                val.Length.ToString(),
+                ((int)val.State).ToString(),
+                ((int)val.FailureReason).ToString(),
+            };
+
+            writeCsvLine(items);
+            writer.Write(';');
+        }
+
+        writer.Write('\n');
+    }
+
+    private string TrackToLine(Track track, string? failureReason = null)
+    {
+        if (failureReason != null)
+            return $"# Failed: {track} [{failureReason}]";
+        if (track.DownloadPath.Length > 0)
+        {
+            if (track.DownloadPath.StartsWith(parent))
+                return Path.GetRelativePath(parent, track.DownloadPath);
+            else
+                return track.DownloadPath;
+        }
+        return $"# {track}";
+    }
+
+    public Track? PreviousRunResult(Track track)
+    {
+        previousRunTracks.TryGetValue(track.ToKey(), out var t);
+        return t;
+    }
+
+    public bool TryGetPreviousRunResult(Track track, out Track? result)
+    {
+        previousRunTracks.TryGetValue(track.ToKey(), out result);
+        return result != null;
+    }
+
+    public bool TryGetFailureReason(Track track, out FailureReason reason)
+    {
+        reason = FailureReason.None;
+        var t = PreviousRunResult(track);
+        if (t != null && t.State == TrackState.Failed)
+        {
+            reason = t.FailureReason;
+            return true;
+        }
+        return false;
+    }
+
+    private string ReadAllText()
+    {
+        if (!File.Exists(path))
+            return "";
+        using var fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+        using var streamReader = new StreamReader(fileStream);
+        return streamReader.ReadToEnd();
+    }
+
+    private string[] ReadAllLines()
+    {
+        return ReadAllText().TrimEnd().Split('\n');
+    }
+}
\ No newline at end of file
diff --git a/slsk-batchdl/Program.cs b/slsk-batchdl/Program.cs
index 3834be3..ac5d482 100644
--- a/slsk-batchdl/Program.cs
+++ b/slsk-batchdl/Program.cs
@@ -1,1052 +1,97 @@
-using AngleSharp.Dom;
+using AngleSharp.Text;
 using Konsole;
 using Soulseek;
 using System.Collections.Concurrent;
 using System.Data;
-using System.Text.RegularExpressions;
-using HtmlAgilityPack;
-using AngleSharp.Text;
 using System.Diagnostics;
+using System.Text.RegularExpressions;
 
+using Data;
+using Enums;
+
+using Directory = System.IO.Directory;
+using File = System.IO.File;
 using ProgressBar = Konsole.ProgressBar;
 using SearchResponse = Soulseek.SearchResponse;
-using SlResponse = Soulseek.SearchResponse;
 using SlFile = Soulseek.File;
-using File = System.IO.File;
-using Directory = System.IO.Directory;
-using SlDictionary = System.Collections.Concurrent.ConcurrentDictionary<string, (Soulseek.SearchResponse, Soulseek.File)>;
+using SlResponse = Soulseek.SearchResponse;
 
 
-// todo
-// - Why does it use so much CPU and memory?
-// - Very slow startup time on linux
-
-// undocumented options
-// --on-complete
-// --artist-col, --title-col, --album-col, --length-col, --yt-desc-col, --yt-id-col, --album-track-count-col
-// --input-type, --login, --random-login, --no-modify-share-count, --unknown-error-retries
-// --fails-to-deprioritize (=1), --fails-to-ignore (=2), --invalid-replace-str
-// --cond, --pref, --danger-words, --pref-danger-words, --strict-title, --strict-artist, --strict-album
-// --fast-search-delay, --fast-search-min-up-speed
-// --min-album-track-count, --max-album-track-count, --extract-max-track-count
-
-static class Program
+static partial class Program
 {
-    static FileConditions necessaryCond = new()
-    {
-
-    };
-
-    static FileConditions preferredCond = new()
-    {
-        Formats = new string[] { "mp3" },
-        LengthTolerance = 3,
-        MinBitrate = 200,
-        MaxBitrate = 2500,
-        MaxSampleRate = 48000,
-        StrictTitle = true,
-        StrictAlbum = true,
-        AcceptNoLength = false,
-    };
-
-    static SoulseekClient? client = null;
-    static TrackLists trackLists = new();
-    static ConcurrentDictionary<Track, SearchInfo> searches = new();
-    static ConcurrentDictionary<string, DownloadWrapper> downloads = new();
-    static ConcurrentDictionary<string, int> userSuccessCount = new();
-    static int deprioritizeOn = -1;
-    static int ignoreOn = -2;
-    static string outputFolder = "";
-    static string m3uFilePath = "";
-    static string musicDir = "";
-
-    static string parentFolder = Directory.GetCurrentDirectory();
-    static string folderName = "";
-    static string defaultFolderName = "";
-    static string ytUrl = "";
-    static string searchStr = "";
-    static string spotifyUrl = "";
-    static string spotifyId = "";
-    static string spotifySecret = "";
-    static string ytKey = "";
-    static string csvPath = "";
-    static int csvColumnCount = -1;
-    static string username = "";
-    static string password = "";
-    static string artistCol = "";
-    static string albumCol = "";
-    static string trackCol = "";
-    static string ytIdCol = "";
-    static string descCol = "";
-    static string trackCountCol = "";
-    static string lengthCol = "";
-    static bool aggregate = false;
-    static bool album = false;
-    static string albumArtOption = "";
-    static bool albumArtOnly = false;
-    static bool interactiveMode = false;
-    static bool albumIgnoreFails = false;
-    static int minAlbumTrackCount = -1;
-    static int maxAlbumTrackCount = -1;
-    static bool setAlbumMinTrackCount = true;
-    static bool setAlbumMaxTrackCount = false;
-    static string albumCommonPath = "";
-    static Track regexToReplace = new Track();
-    static Track regexReplaceBy = new Track();
-    static string timeUnit = "s";
-    static string displayStyle = "single";
-    static string input = "";
-    static string nameFormat = "";
-    static string invalidReplaceStr = " ";
-    static bool skipNotFound = false;
-    static bool desperateSearch = false;
-    static bool noRemoveSpecialChars = false;
-    static bool artistMaybeWrong = false;
-    static bool fastSearch = false;
-    static int fastSearchDelay = 300;
-    static double fastSearchMinUpSpeed = 1.0;
-    static bool ytParse = false;
-    static bool removeFt = false;
-    static bool removeBrackets = false;
-    static bool reverse = false;
-    static bool useYtdlp = false;
-    static string ytdlpArgument = "";
-    static bool skipExisting = false;
-    static string m3uOption = "fails";
-    static bool removeTracksFromSource = false;
-    static bool getDeleted = false;
-    static bool deletedOnly = false;
-    static bool removeSingleCharacterSearchTerms = false;
-    static int maxTracks = int.MaxValue;
-    static int minUsersAggregate = 2;
-    static bool relax = false;
-    static bool debugInfo = false;
-    static int offset = 0;
-    static string onComplete = "";
-
-    static string confPath = "";
-
-    static Spotify? spotifyClient = null;
-    static string playlistUri = "";
-    static int downloadMaxStaleTime = 50000;
-    static int updateDelay = 100;
-    static int searchTimeout = 5000;
-    static int maxConcurrentProcesses = 2;
-    static int unknownErrorRetries = 2;
-    static int maxRetriesPerTrack = 30;
-    static int listenPort = 50000;
-
-    static object consoleLock = new object();
-    static object csvLock = new object();
-
-    static bool skipUpdate = false;
-    static bool debugDisableDownload = false;
-    static bool debugPrintTracks = false;
-    static bool noModifyShareCount = false;
-    static bool printResultsFull = false;
-    static bool debugPrintTracksFull = false;
-    static bool useRandomLogin = false;
-
-    static int searchesPerTime = 34;
-    static int searchResetTime = 220;
+    public static Extractors.IExtractor? extractor;
+    public static SoulseekClient? client;
+    public static TrackLists? trackLists;
+    public static M3uEditor? m3uEditor;
     static RateLimitedSemaphore? searchSemaphore;
-
-    private static M3UEditor? m3uEditor;
-    private static CancellationTokenSource? mainLoopCts;
-
-    static InputType inputType = InputType.None;
-
-    public enum InputType
-    {
-        None,
-        Spotify,
-        YouTube,
-        Bandcamp,
-        String,
-        CSV
-    };
-
-    static SkipMode skipMode = SkipMode.NamePrecise;
-
-    public enum SkipMode
-    {
-        Name,
-        NamePrecise,
-        Tag,
-        TagPrecise,
-        M3u,
-    };
-
-    static void PrintHelp()
-    {
-        Console.WriteLine("Usage: sldl <input> [OPTIONS]" +
-                            "\n" +
-                            "\n  <input>                        <input> is one of the following:" +
-                            "\n" +
-                            "\n                                 Spotify playlist url or 'spotify-likes': Download a spotify" +
-                            "\n                                 playlist or your liked songs. --spotify-id and" +
-                            "\n                                 --spotify-secret may be required in addition." +
-                            "\n" +
-                            "\n                                 Youtube playlist url: Download songs from a youtube playlist." +
-                            "\n                                 Provide a --youtube-key to include unavailabe uploads." +
-                            "\n" +
-                            "\n                                 Path to a local CSV file: Use a csv file containing track" +
-                            "\n                                 info to download. The names of the columns should be Artist," +
-                            "\n                                 Title, Album, Length. Only the title or album column is" +
-                            "\n                                 required, but extra info may improve search results." +
-                            "\n" +
-                            "\n                                 Name of the track, album, or artist to search for:" +
-                            "\n                                 Can either be any typical search string or a comma-separated" +
-                            "\n                                 list like 'title=Song Name,artist=Artist Name,length=215'" +
-                            "\n                                 Allowed properties are: title, artist, album, length (sec)" +
-                            "\n                                 Specify artist and album only to download an album." +
-                            "\n" +
-                            "\nOptions:" +
-                            "\n  --user <username>              Soulseek username" +
-                            "\n  --pass <password>              Soulseek password" +
-                            "\n" +
-                            "\n  -p --path <path>               Download directory" +
-                            "\n  -f --folder <name>             Subfolder name. Set to '.' to output directly to the" +
-                            "\n                                 download folder (default: playlist/csv name)" +
-                            "\n  -n --number <maxtracks>        Download the first n tracks of a playlist" +
-                            "\n  -o --offset <offset>           Skip a specified number of tracks" +
-                            "\n  -r --reverse                   Download tracks in reverse order" +
-                            "\n  --name-format <format>         Name format for downloaded tracks, e.g \"{artist} - {title}\"" +
-                            "\n  --fast-search                  Begin downloading as soon as a file satisfying the preferred" +
-                            "\n                                 conditions is found. Higher chance to download wrong files." +
-                            "\n  --remove-from-source           Remove downloaded tracks from source playlist or CSV file " +
-                            "\n                                 (spotify and CSV only)" +
-                            "\n  --m3u <option>                 Create an m3u8 playlist file" +
-                            "\n                                 'none': Do not create a playlist file" +
-                            "\n                                 'fails' (default): Write only failed downloads to the m3u" +
-                            "\n                                 'all': Write successes + fails as comments" +
-                            "\n" +
-                            "\n  --spotify-id <id>              spotify client ID" +
-                            "\n  --spotify-secret <secret>      spotify client secret" +
-                            "\n" +
-                            "\n  --youtube-key <key>            Youtube data API key" +
-                            "\n  --get-deleted                  Attempt to retrieve titles of deleted videos from wayback" +
-                            "\n                                 machine. Requires yt-dlp." +
-                            "\n  --deleted-only                 Only retrieve & download deleted music. Combine with --print" +
-                            "\n                                 tracks-full to display a list of all deleted titles & urls." +
-                            "\n" +
-                            "\n  --time-format <format>         Time format in Length column of the csv file (e.g h:m:s.ms" +
-                            "\n                                 for durations like 1:04:35.123). Default: s" +
-                            "\n  --yt-parse                     Enable if the csv file contains YouTube video titles and" +
-                            "\n                                 channel names; attempt to parse them into title and artist" +
-                            "\n                                 names." +
-                            "\n" +
-                            "\n  --format <format>              Accepted file format(s), comma-separated" +
-                            "\n  --length-tol <sec>             Length tolerance in seconds" +
-                            "\n  --min-bitrate <rate>           Minimum file bitrate" +
-                            "\n  --max-bitrate <rate>           Maximum file bitrate" +
-                            "\n  --min-samplerate <rate>        Minimum file sample rate" +
-                            "\n  --max-samplerate <rate>        Maximum file sample rate" +
-                            "\n  --min-bitdepth <depth>         Minimum bit depth" +
-                            "\n  --max-bitdepth <depth>         Maximum bit depth" +
-                            "\n  --banned-users <list>          Comma-separated list of users to ignore" +
-                            "\n" +
-                            "\n  --pref-format <format>         Preferred file format(s), comma-separated (default: mp3)" +
-                            "\n  --pref-length-tol <sec>        Preferred length tolerance in seconds (default: 3)" +
-                            "\n  --pref-min-bitrate <rate>      Preferred minimum bitrate (default: 200)" +
-                            "\n  --pref-max-bitrate <rate>      Preferred maximum bitrate (default: 2500)" +
-                            "\n  --pref-min-samplerate <rate>   Preferred minimum sample rate" +
-                            "\n  --pref-max-samplerate <rate>   Preferred maximum sample rate (default: 48000)" +
-                            "\n  --pref-min-bitdepth <depth>    Preferred minimum bit depth" +
-                            "\n  --pref-max-bitdepth <depth>    Preferred maximum bit depth" +
-                            "\n  --pref-banned-users <list>     Comma-separated list of users to deprioritize" +
-                            "\n" +
-                            "\n  --strict-conditions            Skip files with missing properties instead of accepting by" +
-                            "\n                                 default; if --min-bitrate is set, ignores any files with" +
-                            "\n                                 unknown bitrate." +
-                            "\n" +
-                            "\n  -a --album                     Album download mode" +
-                            "\n  -t --interactive               When downloading albums: Allows to select the wanted album" +
-                            "\n  --album-track-count <num>      Specify the exact number of tracks in the album. Folders" +
-                            "\n                                 with a different number of tracks will be ignored. Append" +
-                            "\n                                 a '+' or '-' after the number for the inequalities >= and <=" +
-                            "\n  --album-ignore-fails           When downloading an album and one of the files fails, do not" +
-                            "\n                                 skip to the next source and do not delete all successfully" +
-                            "\n                                 downloaded files" +
-                            "\n  --album-art <option>           Retrieve additional images after downloading the album:" +
-                            "\n                                 'largest': Download from the folder with the largest image" +
-                            "\n                                 'most': Download from the folder containing the most images" +
-                            "\n  --album-art-only               Only download album art for the provided album" +
-                            "\n" +
-                            "\n  -g --aggregate                 Instead of downloading a single track matching the input," +
-                            "\n                                 find and download all distinct songs associated with the" +
-                            "\n                                 provided artist, album, or track title." +
-                            "\n  --min-users-aggregate <num>    Minimum number of users sharing a track before it is" +
-                            "\n                                 downloaded in aggregate mode. Setting it to higher values" +
-                            "\n                                 will significantly reduce false positives, but also cause it" +
-                            "\n                                 to ignore rarer songs. Default: 2" +
-                            "\n  --relax-filtering              Slightly relax file filtering in aggregate mode to include" +
-                            "\n                                 more results" +
-                            "\n" +
-                            "\n  -s --skip-existing             Skip if a track matching file conditions is found in the" +
-                            "\n                                 output folder or your music library (if provided)" +
-                            "\n  --skip-mode <mode>             'name': Use only filenames to check if a track exists" +
-                            "\n                                 'name-precise' (default): Use filenames and check conditions" +
-                            "\n                                 'tag': Use file tags (slower)" +
-                            "\n                                 'tag-precise': Use file tags and check file conditions" +
-                            "\n                                 'm3u': Skip all tracks that don't have a fail entry in m3u" +
-                            "\n  --music-dir <path>             Specify to also skip downloading tracks found in a music" +
-                            "\n                                 library. Use with --skip-existing" +
-                            "\n  --skip-not-found               Skip searching for tracks that weren't found on Soulseek" +
-                            "\n                                 during the last run. Fails are read from the m3u file." +
-                            "\n" +
-                            "\n  --no-remove-special-chars      Do not remove special characters before searching" +
-                            "\n  --remove-ft                    Remove 'feat.' and everything after before searching" +
-                            "\n  --remove-brackets              Remove square brackets and their contents before searching" +
-                            "\n  --regex <regex>                Remove a regexp from all track titles and artist names." +
-                            "\n                                 Optionally specify a replacement regex after a semicolon." +
-                            "\n                                 Add 'T:', 'A:' or 'L:' at the start to only apply this to" +
-                            "\n                                 the track title, artist, or album respectively." +
-                            "\n  --artist-maybe-wrong           Performs an additional search without the artist name." +
-                            "\n                                 Useful for sources like SoundCloud where the \"artist\"" +
-                            "\n                                 could just be an uploader. Note that when downloading a" +
-                            "\n                                 YouTube playlist via url, this option is set automatically" +
-                            "\n                                 on a per-track basis, so it is best kept off in that case." +
-                            "\n  -d --desperate                 Tries harder to find the desired track by searching for the" +
-                            "\n                                 artist/album/title only, then filtering. (slower search)" +
-                            "\n  --yt-dlp                       Use yt-dlp to download tracks that weren't found on" +
-                            "\n                                 Soulseek. yt-dlp must be available from the command line." +
-                            "\n  --yt-dlp-argument <str>        The command line arguments when running yt-dlp. Default:" +
-                            "\n                                 \"{id}\" -f bestaudio/best -cix -o \"{savepath}.%(ext)s\"" +
-                            "\n                                 Available vars are: {id}, {savedir}, {savepath} (w/o ext)." +
-                            "\n                                 Note that with -x, yt-dlp will download webms in case" +
-                            "\n                                 ffmpeg is unavailable." +
-                            "\n" +
-                            "\n  -c --config <path>             Set config file location" +
-                            "\n  --search-timeout <ms>          Max search time in ms (default: 5000)" +
-                            "\n  --max-stale-time <ms>          Max download time without progress in ms (default: 50000)" +
-                            "\n  --concurrent-downloads <num>   Max concurrent downloads (default: 2)" +
-                            "\n  --searches-per-time <num>      Max searches per time interval. Higher values may cause" +
-                            "\n                                 30-minute bans. (default: 34)" +
-                            "\n  --searches-renew-time <sec>    Controls how often available searches are replenished." +
-                            "\n                                 Lower values may cause 30-minute bans. (default: 220)" +
-                            "\n  --display-mode <option>        Changes how searches and downloads are displayed:" +
-                            "\n                                 'single' (default): Show transfer state and percentage" +
-                            "\n                                 'double': Transfer state and a large progress bar " +
-                            "\n                                 'simple': No download bars or changing percentages" +
-                            "\n  --listen-port <port>           Port for incoming connections (default: 50000)" +
-                            "\n" +
-                            "\n  --print <option>               Print tracks or search results instead of downloading:" +
-                            "\n                                 'tracks': Print all tracks to be downloaded" +
-                            "\n                                 'tracks-full': Print extended information about all tracks" +
-                            "\n                                 'results': Print search results satisfying file conditions" +
-                            "\n                                 'results-full': Print search results including full paths" +
-                            "\n  --debug                        Print extra debug info" +
-                            "\n" +
-                            "\n  Note: Acronyms of two- and --three-word-arguments are also accepted, e.g. --twa");
-    }
+    static CancellationTokenSource? mainLoopCts;
+    static readonly ConcurrentDictionary<Track, SearchInfo> searches = new();
+    static readonly ConcurrentDictionary<string, DownloadWrapper> downloads = new();
+    static readonly ConcurrentDictionary<string, int> userSuccessCount = new();
+    static bool skipUpdate = false;
+    static bool initialized = false;
+    static string? soulseekFolderPathPrefix;
+    static readonly object consoleLock = new();
 
     static async Task Main(string[] args)
     {
         Console.ResetColor();
         Console.OutputEncoding = System.Text.Encoding.UTF8;
 
-        if (args.Contains("--help") || args.Contains("-h") || args.Length == 0)
+        int helpIdx = Array.FindIndex(args, x => x == "--help" || x == "-h");
+        if (args.Length == 0 || helpIdx >= 0)
         {
-            PrintHelp();
+            string option = helpIdx + 1 < args.Length ? args[helpIdx + 1] : "";
+            Help.PrintHelp(option);
             return;
         }
 
-#if WINDOWS
-        try
-        {
-            if (Console.BufferHeight <= 50 && displayStyle != "simple")
-                WriteLine("Windows: Recommended to use the default command prompt to avoid printing issues.");
-        }
-        catch { }
-#endif
+        bool doContinue = Config.ParseArgsAndReadConfig(args);
 
-        confPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "sldl.conf");
-        string old = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "slsk-batchdl.conf");
+        if (!doContinue)
+            return;
 
-        if (!File.Exists(confPath) && File.Exists(old))
-            confPath = old;
-
-        args = args.SelectMany(arg =>
-        {
-            if (arg.Length > 3 && arg.StartsWith("--") && arg.Contains('='))
-            {
-                var parts = arg.Split('=', 2);
-                return new[] { parts[0], parts[1] };
-            }
-            return new[] { arg };
-        }).ToArray();
-
-        bool confPathChanged = false;
-        int idx = Array.LastIndexOf(args, "-c");
-        int idx2 = Array.LastIndexOf(args, "--config");
-        idx = idx > -1 ? idx : idx2;
-        if (idx != -1)
-        {
-            confPath = args[idx + 1];
-            confPathChanged = true;
-        }
-
-        if ((File.Exists(confPath) || confPathChanged) && confPath != "none")
-        {
-            if (File.Exists(Path.Join(AppDomain.CurrentDomain.BaseDirectory, confPath)))
-                confPath = Path.Join(AppDomain.CurrentDomain.BaseDirectory, confPath);
-
-            var finalArgs = new List<string>(ParseConfig(confPath));
-            finalArgs.AddRange(args);
-            args = finalArgs.ToArray();
-        }
-
-        if (args.Contains("--strict") || args.Contains("--strict-conditions") || args.Contains("--sc"))
-        {
-            preferredCond.AcceptMissingProps = false;
-            necessaryCond.AcceptMissingProps = false;
-            preferredCond.UnsetClientSpecificFields();
-            necessaryCond.UnsetClientSpecificFields();
-        }
-
-        args = args.SelectMany(arg => 
-        {
-            if (arg.Length > 2 && arg[0] == '-' && arg[1] != '-' && !arg.Contains(' ') && arg.ToLower() == arg)
-                return arg.Substring(1).Select(c => $"-{c}");
-            return new[] { arg };
-        }).ToArray();
-
-        for (int i = 0; i < args.Length; i++)
-        {
-            if (args[i].StartsWith("-"))
-            {
-                switch (args[i])
-                {
-                    case "-i":
-                    case "--input":
-                        input = args[++i];
-                        break;
-                    case "--it":
-                    case "--input-type":
-                        inputType = args[++i].ToLower().Trim() switch
-                        {
-                            "none" => InputType.None,
-                            "csv" => InputType.CSV,
-                            "youtube" => InputType.YouTube,
-                            "spotify" => InputType.Spotify,
-                            "bandcamp" => InputType.Bandcamp,
-                            "string" => InputType.String,
-                            _ => throw new ArgumentException($"Invalid input type '{args[i]}'"),
-                        };
-                        break;
-                    case "-p":
-                    case "--path":
-                        parentFolder = args[++i];
-                        break;
-                    case "-c":
-                    case "--config":
-                        confPath = args[++i];
-                        break;
-                    case "-f":
-                    case "--folder":
-                        folderName = args[++i];
-                        break;
-                    case "-m":
-                    case "--md":
-                    case "--music-dir":
-                        musicDir = args[++i];
-                        break;
-                    case "-g":
-                    case "--aggregate":
-                        aggregate = true;
-                        break;
-                    case "--mua":
-                    case "--min-users-aggregate":
-                        minUsersAggregate = int.Parse(args[++i]);
-                        break;
-                    case "--rf":
-                    case "--relax":
-                    case "--relax-filtering":
-                        relax = true;
-                        break;
-                    case "--si":
-                    case "--spotify-id":
-                        spotifyId = args[++i];
-                        break;
-                    case "--ss":
-                    case "--spotify-secret":
-                        spotifySecret = args[++i];
-                        break;
-                    case "--yk":
-                    case "--youtube-key":
-                        ytKey = args[++i];
-                        break;
-                    case "-l":
-                    case "--login":
-                        var login = args[++i].Split(';',2);
-                        username = login[0];
-                        password = login[1];
-                        break;
-                    case "--user":
-                    case "--username":
-                        username = args[++i];
-                        break;
-                    case "--pass":
-                    case "--password":
-                        password = args[++i];
-                        break;
-                    case "--rl":
-                    case "--random-login":
-                        useRandomLogin = true;
-                        break;
-                    case "--artist-col":
-                        artistCol = args[++i];
-                        break;
-                    case "--track-col":
-                        trackCol = args[++i];
-                        break;
-                    case "--album-col":
-                        albumCol = args[++i];
-                        break;
-                    case "--yt-desc-col":
-                        descCol = args[++i];
-                        break;
-                    case "--album-track-count-col":
-                        trackCountCol = args[++i];
-                        break;
-                    case "--yt-id-col":
-                        ytIdCol = args[++i];
-                        break;
-                    case "-n":
-                    case "--number":
-                        maxTracks = int.Parse(args[++i]);
-                        break;
-                    case "-o":
-                    case "--offset":
-                        offset = int.Parse(args[++i]);
-                        break;
-                    case "--nf":
-                    case "--name-format":
-                        nameFormat = args[++i];
-                        break;
-                    case "--invalid-replace-str":
-                        invalidReplaceStr = args[++i];
-                        break;
-                    case "--p":
-                    case "--print":
-                        string opt = args[++i];
-                        if (opt == "tracks")
-                        {
-                            debugPrintTracks = true;
-                            debugDisableDownload = true;
-                        }
-                        else if (opt == "tracks-full")
-                        {
-                            debugPrintTracks = true;
-                            debugPrintTracksFull = true;
-                            debugDisableDownload = true;
-                        }
-                        else if (opt == "results")
-                            debugDisableDownload = true;
-                        else if (opt == "results-full")
-                        {
-                            debugDisableDownload = true;
-                            printResultsFull = true;
-                        }
-                        else
-                            throw new ArgumentException($"Unknown print option {opt}");
-                        break;
-                    case "--pt":
-                    case "--print-tracks":
-                        debugPrintTracks = true;
-                        debugDisableDownload = true;
-                        break;
-                    case "--ptf":
-                    case "--print-tracks-full":
-                        debugPrintTracks = true;
-                        debugPrintTracksFull = true;
-                        debugDisableDownload = true;
-                        break;
-                    case "--pr":
-                    case "--print-results":
-                        debugDisableDownload = true;
-                        break;
-                    case "--prf":
-                    case "--print-results-full":
-                        debugDisableDownload = true;
-                        printResultsFull = true;
-                        break;
-                    case "--yp":
-                    case "--yt-parse":
-                        ytParse = true;
-                        break;
-                    case "--length-col":
-                        lengthCol = args[++i];
-                        break;
-                    case "--tf":
-                    case "--time-format":
-                        timeUnit = args[++i];
-                        break;
-                    case "--yd":
-                    case "--yt-dlp":
-                        useYtdlp = true;
-                        break;
-                    case "-s":
-                    case "--se":
-                    case "--skip-existing":
-                        skipExisting = true;
-                        break;
-                    case "--snf":
-                    case "--skip-not-found":
-                        skipNotFound = true;
-                        break;
-                    case "--rfp":
-                    case "--rfs":
-                    case "--remove-from-source":
-                    case "--remove-from-playlist":
-                        removeTracksFromSource = true;
-                        break;
-                    case "--rft":
-                    case "--remove-ft":
-                        removeFt = true;
-                        break;
-                    case "--rb":
-                    case "--remove-brackets":
-                        removeBrackets = true;
-                        break;
-                    case "--gd":
-                    case "--get-deleted":
-                        getDeleted = true;
-                        break;
-                    case "--do":
-                    case "--deleted-only":
-                        getDeleted = true;
-                        deletedOnly = true;
-                        break;
-                    case "--re":
-                    case "--regex":
-                        string s = args[++i].Replace("\\;", "<<semicol>>");
-                        string applyTo = "TAL";
-
-                        if (s.Length > 2 && s[1] == ':' && (s[0] == 'T' || s[0] == 'A' || s[0] == 'L'))
-                        {
-                            applyTo = s[0].ToString();
-                            s = s.Substring(2);
-                        }
-
-                        var parts = s.Split(";").ToArray();
-                        string toReplace = parts[0].Replace("<<semicol>>", ";");
-                        string replaceBy = parts.Length > 1 ? parts[1].Replace("<<semicol>>", ";") : "";
-                        
-                        if (applyTo.Contains('T'))
-                        {
-                            regexToReplace.Title = toReplace;
-                            regexReplaceBy.Title = replaceBy;
-                        }
-                        if (applyTo.Contains('A'))
-                        {
-                            regexToReplace.Artist = toReplace;
-                            regexReplaceBy.Artist = replaceBy;
-                        }
-                        if (applyTo.Contains('L'))
-                        {
-                            regexToReplace.Album = toReplace;
-                            regexReplaceBy.Album = replaceBy;
-                        }
-                        break;
-                    case "-r":
-                    case "--reverse":
-                        reverse = true;
-                        break;
-                    case "--m3u":
-                    case "--m3u8":
-                        m3uOption = args[++i];
-                        break;
-                    case "--lp":
-                    case "--port":
-                    case "--listen-port":
-                        listenPort = int.Parse(args[++i]);
-                        break;
-                    case "--st":
-                    case "--timeout":
-                    case "--search-timeout":
-                        searchTimeout = int.Parse(args[++i]);
-                        break;
-                    case "--mst":
-                    case "--stale-time":
-                    case "--max-stale-time":
-                        downloadMaxStaleTime = int.Parse(args[++i]);
-                        break;
-                    case "--cp":
-                    case "--cd":
-                    case "--processes":
-                    case "--concurrent-processes":
-                    case "--concurrent-downloads":
-                        maxConcurrentProcesses = int.Parse(args[++i]);
-                        break;
-                    case "--spt":
-                    case "--searches-per-time":
-                        searchesPerTime = int.Parse(args[++i]);
-                        break;
-                    case "--srt":
-                    case "--searches-renew-time":
-                        searchResetTime = int.Parse(args[++i]);
-                        break;
-                    case "--mr":
-                    case "--retries":
-                    case "--max-retries":
-                        maxRetriesPerTrack = int.Parse(args[++i]);
-                        break;
-                    case "--atc":
-                    case "--album-track-count":
-                        string a = args[++i];
-                        if (a == "-1")
-                        {
-                            minAlbumTrackCount = -1;
-                            maxAlbumTrackCount = -1;
-                        }
-                        else if (a.Last() == '-')
-                        {
-                            maxAlbumTrackCount = int.Parse(a.Substring(0, a.Length - 1));
-                        }
-                        else if (a.Last() == '+')
-                        {
-                            minAlbumTrackCount = int.Parse(a.Substring(0, a.Length - 1));
-                        }
-                        else
-                        {
-                            minAlbumTrackCount = int.Parse(a);
-                            maxAlbumTrackCount = minAlbumTrackCount;
-                        }
-                        break;
-                    case "--matc":
-                    case "--min-album-track-count":
-                        minAlbumTrackCount = int.Parse(args[++i]);
-                        break;
-                    case "--Matc":
-                    case "--max-album-track-count":
-                        maxAlbumTrackCount = int.Parse(args[++i]);
-                        break;
-                    case "--eMtc":
-                    case "--extract-max-track-count":
-                        setAlbumMaxTrackCount = true;
-                        break;
-                    case "--aa":
-                    case "--album-art":
-                        switch (args[++i])
-                        {
-                            case "largest":
-                            case "most":
-                                albumArtOption = args[i];
-                                break;
-                            case "default":
-                                albumArtOption = "";
-                                break;
-                            default:
-                                throw new ArgumentException($"Invalid album art download mode '{args[i]}'");
-                        }
-                        break;
-                    case "--aao":
-                    case "--aa-only":
-                    case "--album-art-only":
-                        albumArtOnly = true;
-                        if (albumArtOption == "")
-                        {
-                            albumArtOption = "largest";
-                        }
-                        preferredCond = new FileConditions();
-                        necessaryCond = new FileConditions();
-                        break;
-                    case "--aif":
-                    case "--album-ignore-fails":
-                        albumIgnoreFails = true;
-                        break;
-                    case "-t":
-                    case "--interactive":
-                        interactiveMode = true;
-                        break;
-                    case "--pf":
-                    case "--paf":
-                    case "--pref-format":
-                        preferredCond.Formats = args[++i].Split(',', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries);
-                        break;
-                    case "--plt":
-                    case "--pref-tolerance":
-                    case "--pref-length-tol":
-                    case "--pref-length-tolerance":
-                        preferredCond.LengthTolerance = int.Parse(args[++i]);
-                        break;
-                    case "--pmbr":
-                    case "--pref-min-bitrate":
-                        preferredCond.MinBitrate = int.Parse(args[++i]);
-                        break;
-                    case "--pMbr":
-                    case "--pref-max-bitrate":
-                        preferredCond.MaxBitrate = int.Parse(args[++i]);
-                        break;
-                    case "--pmsr":
-                    case "--pref-min-samplerate":
-                        preferredCond.MinSampleRate = int.Parse(args[++i]);
-                        break;
-                    case "--pMsr":
-                    case "--pref-max-samplerate":
-                        preferredCond.MaxSampleRate = int.Parse(args[++i]);
-                        break;
-                    case "--pmbd":
-                    case "--pref-min-bitdepth":
-                        preferredCond.MinBitDepth = int.Parse(args[++i]);
-                        break;
-                    case "--pMbd":
-                    case "--pref-max-bitdepth":
-                        preferredCond.MaxBitDepth = int.Parse(args[++i]);
-                        break;
-                    case "--pdw":
-                    case "--pref-danger-words":
-                        preferredCond.DangerWords = args[++i].Split(',');
-                        break;
-                    case "--pst":
-                    case "--pstt":
-                    case "--pref-strict-title":
-                        preferredCond.StrictTitle = true;
-                        break;
-                    case "--psa":
-                    case "--pref-strict-artist":
-                        preferredCond.StrictArtist = true;
-                        break;
-                    case "--psal":
-                    case "--pref-strict-album":
-                        preferredCond.StrictAlbum = true;
-                        break;
-                    case "--pbu":
-                    case "--pref-banned-users":
-                        preferredCond.BannedUsers = args[++i].Split(',');
-                        break;
-                    case "--af":
-                    case "--format":
-                        necessaryCond.Formats = args[++i].Split(',', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries);
-                        break;
-                    case "--lt":
-                    case "--tolerance":
-                    case "--length-tol":
-                    case "--length-tolerance":
-                        necessaryCond.LengthTolerance = int.Parse(args[++i]);
-                        break;
-                    case "--mbr":
-                    case "--min-bitrate":
-                        necessaryCond.MinBitrate = int.Parse(args[++i]);
-                        break;
-                    case "--Mbr":
-                    case "--max-bitrate":
-                        necessaryCond.MaxBitrate = int.Parse(args[++i]);
-                        break;
-                    case "--msr":
-                    case "--min-samplerate":
-                        necessaryCond.MinSampleRate = int.Parse(args[++i]);
-                        break;
-                    case "--Msr":
-                    case "--max-samplerate":
-                        necessaryCond.MaxSampleRate = int.Parse(args[++i]);
-                        break;
-                    case "--mbd":
-                    case "--min-bitdepth":
-                        necessaryCond.MinBitDepth = int.Parse(args[++i]);
-                        break;
-                    case "--Mbd":
-                    case "--max-bitdepth":
-                        necessaryCond.MaxBitDepth = int.Parse(args[++i]);
-                        break;
-                    case "--dw":
-                    case "--danger-words":
-                        necessaryCond.DangerWords = args[++i].Split(',');
-                        break;
-                    case "--stt":
-                    case "--strict-title":
-                        necessaryCond.StrictTitle = true;
-                        break;
-                    case "--sa":
-                    case "--strict-artist":
-                        necessaryCond.StrictArtist = true;
-                        break;
-                    case "--sal":
-                    case "--strict-album":
-                        necessaryCond.StrictAlbum = true;
-                        break;
-                    case "--bu":
-                    case "--banned-users":
-                        necessaryCond.BannedUsers = args[++i].Split(',');
-                        break;
-                    case "--c":
-                    case "--cond":
-                    case "--conditions":
-                        ParseConditions(necessaryCond, args[++i]);
-                        break;
-                    case "--pc":
-                    case "--pref":
-                    case "--preferred-conditions":
-                        ParseConditions(preferredCond, args[++i]);
-                        break;
-                    case "--nmsc":
-                    case "--no-modify-share-count":
-                        noModifyShareCount = true;
-                        break;
-                    case "-d":
-                    case "--desperate":
-                        desperateSearch = true;
-                        break;
-                    case "--dm":
-                    case "--display":
-                    case "--display-mode":
-                        switch (args[++i])
-                        {
-                            case "single":
-                            case "double":
-                            case "simple":
-                                displayStyle = args[i];
-                                break;
-                            default:
-                                throw new ArgumentException($"Invalid display style '{args[i]}'");
-                        }
-                        break;
-                    case "--sm":
-                    case "--skip-mode":
-                        skipMode = args[++i].ToLower().Trim() switch
-                        {
-                            "name" => SkipMode.Name,
-                            "name-precise" => SkipMode.NamePrecise,
-                            "tag" => SkipMode.Tag,
-                            "tag-precise" => SkipMode.TagPrecise,
-                            "m3u" => SkipMode.M3u,
-                            _ => throw new ArgumentException($"Invalid skip mode '{args[i]}'"),
-                        };
-                        break;
-                    case "--nrsc":
-                    case "--no-remove-special-chars":
-                        noRemoveSpecialChars = true;
-                        break;
-                    case "--amw":
-                    case "--artist-maybe-wrong":
-                        artistMaybeWrong = true;
-                        break;
-                    case "--fs":
-                    case "--fast-search":
-                        fastSearch = true;
-                        break;
-                    case "--fsd":
-                    case "--fast-search-delay":
-                        fastSearchDelay = int.Parse(args[++i]);
-                        break;
-                    case "--fsmus":
-                    case "--fast-search-min-up-speed":
-                        fastSearchMinUpSpeed = double.Parse(args[++i]);
-                        break;
-                    case "--debug":
-                        debugInfo = true;
-                        break;
-                    case "--sc":
-                    case "--strict":
-                    case "--strict-conditions":
-                        preferredCond.AcceptMissingProps = false;
-                        necessaryCond.AcceptMissingProps = false;
-                        break;
-                    case "--yda":
-                    case "--yt-dlp-argument":
-                        ytdlpArgument = args[++i];
-                        break;
-                    case "-a":
-                    case "--album":
-                        album = true;
-                        break;
-                    case "--oc":
-                    case "--on-complete":
-                        onComplete = args[++i];
-                        break;
-                    case "--ftd":
-                    case "--fails-to-deprioritize":
-                        deprioritizeOn = -int.Parse(args[++i]);
-                        break;
-                    case "--fti":
-                    case "--fails-to-ignore":
-                        ignoreOn = -int.Parse(args[++i]);
-                        break;
-                    case "--unknown-error-retries":
-                        unknownErrorRetries = int.Parse(args[++i]);
-                        break;
-                    default:
-                        throw new ArgumentException($"Unknown argument: {args[i]}");
-                }
-            }
-            else
-            {
-                if (input == "")
-                    input = args[i].Trim();
-                else
-                    throw new ArgumentException($"Invalid argument \'{args[i]}\'. Input is already set to \'{input}\'");
-            }
-        }
-
-        if (input == "")
+        if (Config.input.Length == 0)
             throw new ArgumentException($"No input provided");
 
-        if (ytKey != "")
-            YouTube.apiKey = ytKey;
+        (Config.inputType, extractor) = Extractors.ExtractorRegistry.GetMatchingExtractor(Config.input);
 
-        if (debugDisableDownload)
-            maxConcurrentProcesses = 1;
+        if (Config.inputType == InputType.None)
+            throw new ArgumentException($"No matching extractor for input '{Config.input}'");
 
-        ignoreOn = Math.Min(ignoreOn, deprioritizeOn);
+        WriteLine($"Using extractor: {Config.inputType}", debugOnly: true);
 
-        if (inputType == InputType.YouTube || (inputType == InputType.None && input.StartsWith("http") && input.Contains("youtu")))
-        {
-            WriteLine("Youtube download", debugOnly: true);
-            await YoutubeInput();
-        }
-        else if (inputType == InputType.Spotify || (inputType == InputType.None && (input.StartsWith("http") && input.Contains("spotify")) || input == "spotify-likes"))
-        {
-            WriteLine("Spotify download", debugOnly: true);
-            await SpotifyInput();
-        }
-        else if (inputType == InputType.Bandcamp || (inputType == InputType.None && input.StartsWith("http") && input.Contains("bandcamp")))
-        {
-            WriteLine("Bandcamp download", debugOnly: true);
-            await BandcampInput();
-        }
-        else if (inputType == InputType.CSV || (inputType == InputType.None && input.EndsWith(".csv", StringComparison.OrdinalIgnoreCase)))
-        {
-            WriteLine("CSV download", debugOnly: true);
-            await CsvInput();
-        }
-        else
-        {
-            WriteLine("String download", debugOnly: true);
-            await StringInput();
-        }
+        trackLists = await extractor.GetTracks();
 
         WriteLine("Got tracks", debugOnly: true);
 
-        if (reverse)
+        Config.PostProcessArgs();
+
+        if (Config.reverse)
         {
             trackLists.Reverse();
-            trackLists = TrackLists.FromFlatList(trackLists.Flattened().Skip(offset).Take(maxTracks).ToList(), aggregate, album);
+            trackLists = TrackLists.FromFlattened(trackLists.Flattened(true, false).Skip(Config.offset).Take(Config.maxTracks), Config.aggregate, Config.album);
         }
 
-        PreprocessTrackList(trackLists);
+        m3uEditor = new M3uEditor(Config.m3uFilePath, trackLists, Config.m3uOption, Config.offset);
 
-        if (folderName == "")
-            folderName = defaultFolderName;
-        if (folderName == ".")
-            folderName = "";
-        folderName = folderName.Replace("\\", "/");
-        folderName = String.Join('/', folderName.Split("/").Select(x => x.ReplaceInvalidChars(invalidReplaceStr).Trim()));
-        folderName = folderName.Replace('/', Path.DirectorySeparatorChar);
+        await MainLoop();
+        WriteLine("Mainloop done", debugOnly: true);
+    }
 
-        outputFolder = Path.Combine(parentFolder, folderName);
-        m3uFilePath = Path.Combine((m3uFilePath != "" ? m3uFilePath : outputFolder), (folderName == "" ? "playlist" : folderName) + ".m3u8");
-        m3uOption = debugDisableDownload ? "none" : m3uOption;
-        m3uEditor = new M3UEditor(m3uFilePath, outputFolder, trackLists, offset, m3uOption);
 
-        bool needLogin = !(debugPrintTracks && trackLists.lists.All(x => x.type == TrackLists.ListType.Normal));
+    static async Task InitClientAndUpdateIfNeeded()
+    {
+        if (initialized)
+            return;
+
+        bool needLogin = !Config.PrintTracks;
         if (needLogin)
         {
-            client = new SoulseekClient(new SoulseekClientOptions(listenPort: listenPort));
-            if (!useRandomLogin && (string.IsNullOrEmpty(username) || string.IsNullOrEmpty(password)))
+            client = new SoulseekClient(new SoulseekClientOptions(listenPort: Config.listenPort));
+            if (!Config.useRandomLogin && (string.IsNullOrEmpty(Config.username) || string.IsNullOrEmpty(Config.password)))
                 throw new ArgumentException("No soulseek username or password");
-            await Login(useRandomLogin);
+            await Login(Config.useRandomLogin);
         }
 
         bool needUpdate = needLogin;
@@ -1056,258 +101,52 @@ static class Program
             WriteLine("Update started", debugOnly: true);
         }
 
-        searchSemaphore = new RateLimitedSemaphore(searchesPerTime, TimeSpan.FromSeconds(searchResetTime));
-
-        await MainLoop();
-        WriteLine("Mainloop done", debugOnly: true);
+        searchSemaphore = new RateLimitedSemaphore(Config.searchesPerTime, TimeSpan.FromSeconds(Config.searchRenewTime));
+        initialized = true;
     }
 
 
-    static async Task YoutubeInput()
+    static void PreprocessTracks(TrackListEntry tle)
     {
-        int max = reverse ? int.MaxValue : maxTracks;
-        int off = reverse ? 0 : offset;
-        ytUrl = input;
-        inputType = InputType.YouTube;
-
-        string name;
-        List<Track>? deleted = null;
-        List<Track> tracks = new();
-
-        if (getDeleted)
+        for (int k = 0; k < tle.list.Count; k++)
         {
-            Console.WriteLine("Getting deleted videos..");
-            var archive = new YouTube.YouTubeArchiveRetriever();
-            deleted = await archive.RetrieveDeleted(ytUrl, printFailed: deletedOnly);
-        }
-        if (!deletedOnly)
-        {
-            if (YouTube.apiKey != "")
+            PreprocessTrack(tle.source);
+            foreach (var ls in tle.list)
             {
-                Console.WriteLine("Loading YouTube playlist (API)");
-                (name, tracks) = await YouTube.GetTracksApi(ytUrl, max, off);
-            }
-            else
-            {
-                Console.WriteLine("Loading YouTube playlist");
-                (name, tracks) = await YouTube.GetTracksYtExplode(ytUrl, max, off);
-            }
-        }
-        else
-        {
-            name = await YouTube.GetPlaylistTitle(ytUrl);
-        }
-        if (deleted != null)
-        {
-            tracks.InsertRange(0, deleted);
-        }
-
-        YouTube.StopService();
-        trackLists.AddEntry(tracks);
-
-        if (album || aggregate)
-            trackLists = TrackLists.FromFlatList(trackLists.Flattened().ToList(), aggregate, album);
-
-        defaultFolderName = name.ReplaceInvalidChars(invalidReplaceStr);
-    }
-
-
-    static async Task SpotifyInput()
-    {
-        int max = reverse ? int.MaxValue : maxTracks;
-        int off = reverse ? 0 : offset;
-
-        spotifyUrl = input;
-        inputType = InputType.Spotify;
-
-        string? playlistName;
-        bool needLogin = spotifyUrl == "spotify-likes" || removeTracksFromSource;
-        List<Track> tracks;
-
-        static void readSpotifyCreds()
-        {
-            Console.Write("Spotify client ID:");
-            spotifyId = Console.ReadLine();
-            Console.Write("Spotify client secret:");
-            spotifySecret = Console.ReadLine();
-            Console.WriteLine();
-        }
-
-        if (needLogin && (spotifyId == "" || spotifySecret == ""))
-        {
-            readSpotifyCreds();
-        }
-
-        spotifyClient = new Spotify(spotifyId, spotifySecret);
-        await spotifyClient.Authorize(needLogin, removeTracksFromSource);
-
-        if (spotifyUrl == "spotify-likes")
-        {
-            Console.WriteLine("Loading Spotify likes");
-            tracks = await spotifyClient.GetLikes(max, off);
-            playlistName = "Spotify Likes";
-
-            trackLists.AddEntry(tracks);
-            if (album || aggregate)
-                trackLists = TrackLists.FromFlatList(trackLists.Flattened().ToList(), aggregate, album);
-        }
-        else if (spotifyUrl.Contains("/album/"))
-        {
-            Console.WriteLine("Loading Spotify album");
-            (var source, tracks) = await spotifyClient.GetAlbum(spotifyUrl);
-            playlistName = source.ToString(noInfo: true);
-            trackLists.AddEntry(TrackLists.ListType.Album, source);
-            if (minAlbumTrackCount == -1 && setAlbumMinTrackCount && (maxAlbumTrackCount == -1 || maxAlbumTrackCount >= tracks.Count))
-            {
-                minAlbumTrackCount = tracks.Count;
-            }
-            if (maxAlbumTrackCount == -1 && setAlbumMaxTrackCount && (minAlbumTrackCount == -1 || minAlbumTrackCount <= tracks.Count))
-            {
-                maxAlbumTrackCount = tracks.Count;
-            }
-        }
-        else
-        {
-            try
-            {
-                Console.WriteLine("Loading Spotify playlist");
-                (playlistName, playlistUri, tracks) = await spotifyClient.GetPlaylist(spotifyUrl, max, off);
-            }
-            catch (SpotifyAPI.Web.APIException)
-            {
-                if (!needLogin && !spotifyClient.UsedDefaultCredentials)
+                for (int i = 0; i < ls.Count; i++)
                 {
-                    await spotifyClient.Authorize(true, removeTracksFromSource);
-                    (playlistName, playlistUri, tracks) = await spotifyClient.GetPlaylist(spotifyUrl, max, off);
-                }
-                else if (!needLogin)
-                {
-                    Console.WriteLine("Spotify playlist not found. It may be set to private. Login? [Y/n]");
-                    if (Console.ReadLine()?.ToLower().Trim() == "y")
-                    {
-                        readSpotifyCreds();
-                        spotifyClient = new Spotify(spotifyId, spotifySecret);
-                        await spotifyClient.Authorize(true, removeTracksFromSource);
-                        Console.WriteLine("Loading Spotify playlist");
-                        (playlistName, playlistUri, tracks) = await spotifyClient.GetPlaylist(spotifyUrl, max, off);
-                    }
-                    else
-                    {
-                        Environment.Exit(0);
-                        return;
-                    }
-                }
-                else throw;
-            }
-
-            trackLists.AddEntry(tracks);
-            if (album || aggregate)
-                trackLists = TrackLists.FromFlatList(trackLists.Flattened().ToList(), aggregate, album);
-        }
-
-
-        defaultFolderName = playlistName.ReplaceInvalidChars(invalidReplaceStr);
-    }
-
-
-    static async Task BandcampInput()
-    {
-        inputType = InputType.Bandcamp;
-        bool isAlbum = !input.Contains("/track/");
-
-        var web = new HtmlWeb();
-        var doc = await web.LoadFromWebAsync(input);
-
-        var nameSection = doc.DocumentNode.SelectSingleNode("//div[@id='name-section']");
-        var name = nameSection.SelectSingleNode(".//h2[@class='trackTitle']").InnerText.UnHtmlString().Trim();
-
-        if (isAlbum)
-        {
-            var artist = nameSection.SelectSingleNode(".//h3/span/a").InnerText.UnHtmlString().Trim();
-            var track = new Track() { Artist=artist, Album=name, IsAlbum=true };
-            trackLists.AddEntry(TrackLists.ListType.Album, track);
-
-            if (minAlbumTrackCount == -1 && setAlbumMinTrackCount || maxAlbumTrackCount == -1 && setAlbumMaxTrackCount)
-            {
-                var trackTable = doc.DocumentNode.SelectSingleNode("//*[@id='track_table']");
-                int n = trackTable.SelectNodes(".//tr").Count;
-                if (minAlbumTrackCount == -1 && setAlbumMinTrackCount && (maxAlbumTrackCount == -1 || maxAlbumTrackCount >= n))
-                {
-                    minAlbumTrackCount = n;
-                }
-                if (maxAlbumTrackCount == -1 && setAlbumMaxTrackCount && (minAlbumTrackCount == -1 || minAlbumTrackCount <= n))
-                {
-                    maxAlbumTrackCount = n;
+                    PreprocessTrack(ls[i]);
                 }
             }
-
-            defaultFolderName = track.ToString(true).ReplaceInvalidChars(invalidReplaceStr).Trim();
-        }
-        else
-        {
-            var album = nameSection.SelectSingleNode(".//h3[@class='albumTitle']/span/a").InnerText.UnHtmlString().Trim();
-            var artist = nameSection.SelectSingleNode(".//h3[@class='albumTitle']/span[last()]/a").InnerText.UnHtmlString().Trim();
-            //var timeParts = doc.DocumentNode.SelectSingleNode("//span[@class='time_total']").InnerText.Trim().Split(':');
-            var track = new Track() { Artist=artist, Title=name, Album=album };
-            trackLists.AddEntry(track);
-
-            defaultFolderName = ".";
         }
     }
+    
 
-
-    static async Task CsvInput()
+    static void PreprocessTrack(Track track)
     {
-        int max = reverse ? int.MaxValue : maxTracks;
-        int off = reverse ? 0 : offset;
-
-        csvPath = input;
-        inputType = InputType.CSV;
-
-        if (!File.Exists(csvPath))
-            throw new FileNotFoundException("CSV file not found");
-
-        var tracks = await ParseCsvIntoTrackInfo(csvPath, artistCol, trackCol, lengthCol, albumCol, descCol, ytIdCol, trackCountCol, timeUnit, ytParse);
-        tracks = tracks.Skip(off).Take(max).ToList();
-        trackLists = TrackLists.FromFlatList(tracks, aggregate, album);
-        defaultFolderName = Path.GetFileNameWithoutExtension(csvPath);
-    }
-
-
-    static async Task StringInput()
-    {
-        searchStr = input;
-        inputType = InputType.String;
-        var music = ParseTrackArg(searchStr, album);
-        bool isAlbum = false;
-
-        if (album)
+        if (Config.removeFt)
         {
-            trackLists.AddEntry(TrackLists.ListType.Album, new Track(music) { IsAlbum = true });
+            track.Title = track.Title.RemoveFt();
+            track.Artist = track.Artist.RemoveFt();
         }
-        else if (!aggregate && music.Title != "")
+        if (Config.removeBrackets)
         {
-            trackLists.AddEntry(music);
+            track.Title = track.Title.RemoveSquareBrackets();
         }
-        else if (aggregate)
+        if (Config.regexToReplace.Title.Length + Config.regexToReplace.Artist.Length + Config.regexToReplace.Album.Length > 0)
         {
-            trackLists.AddEntry(TrackLists.ListType.Aggregate, music);
+            track.Title = Regex.Replace(track.Title, Config.regexToReplace.Title, Config.regexReplaceBy.Title);
+            track.Artist = Regex.Replace(track.Artist, Config.regexToReplace.Artist, Config.regexReplaceBy.Artist);
+            track.Album = Regex.Replace(track.Album, Config.regexToReplace.Album, Config.regexReplaceBy.Album);
         }
-        else if (music.Title == "" && music.Album != "")
+        if (Config.artistMaybeWrong)
         {
-            isAlbum = true;
-            music.IsAlbum = true;
-            trackLists.AddEntry(TrackLists.ListType.Album, music);
-        }
-        else
-        {
-            throw new ArgumentException("Need track title or album");
+            track.ArtistMaybeWrong = true;
         }
 
-        if (aggregate || isAlbum || album)
-            defaultFolderName = music.ToString(true).ReplaceInvalidChars(invalidReplaceStr).Trim();
-        else
-            defaultFolderName = ".";
+        track.Artist = track.Artist.Trim();
+        track.Album = track.Album.Trim();
+        track.Title = track.Title.Trim();
     }
 
 
@@ -1315,83 +154,121 @@ static class Program
     {
         for (int i = 0; i < trackLists.lists.Count; i++)
         {
-            var (list, type, source) = trackLists.lists[i];
+            var tle = trackLists[i];
+
+            Config.UpdateArgs(tle);
+
+            PreprocessTracks(tle);
 
             var existing = new List<Track>();
             var notFound = new List<Track>();
 
-            if (skipNotFound)
-            { 
-                (notFound, source) = SkipNotFound(list[0], source);
-                trackLists.SetSource(source, i);
-                foreach (var tracks in list.Skip(1)) SkipNotFound(tracks, source);
+            if (Config.skipNotFound)
+            {
+                if (SetNotFoundLastTime(tle.source))
+                    notFound.Add(tle.source);
+
+                foreach (var tracks in tle.list) 
+                    notFound.AddRange(DoSkipNotFound(tracks));
             }
 
-            if (trackLists.lists.Count > 1 || type != TrackLists.ListType.Normal)
+            if (Config.skipExisting && tle.list != null && tle.type != ListType.Aggregate)
             {
-                string sourceStr = type == TrackLists.ListType.Normal ? "" : $": {source.ToString(noInfo: type == TrackLists.ListType.Album)}";
-                bool needSearchStr = type == TrackLists.ListType.Normal || skipNotFound && source.TrackState == Track.State.NotFoundLastTime;
-                string searchStr = needSearchStr ? "" : $", searching..";
-                Console.WriteLine($"{Enum.GetName(typeof(TrackLists.ListType), type)} download{sourceStr}{searchStr}");
+                for (int j = 0; j < tle.list.Count; j++)
+                    existing.AddRange(DoSkipExisting(tle.list[0], print: i == 0 && j == 0));
             }
 
-            if (!(skipNotFound && source.TrackState == Track.State.NotFoundLastTime))
+            if (Config.PrintTracks)
             {
-                if (type == TrackLists.ListType.Normal)
+                if (tle.type == ListType.Normal)
                 {
-                    // list[0] should already contain the tracks
+                    PrintTracksTbd(tle.list[0].Where(t => t.State == TrackState.Initial).ToList(), existing, notFound, tle.type);
                 }
-                else if (type == TrackLists.ListType.Album)
+                else
                 {
-                    list = await GetAlbumDownloads(source);
-                    trackLists.SetList(list, i);
-                    if (!debugDisableDownload && (list.Count == 0 || list[0].Count == 0))
+                    var tl = new List<Track>();
+                    if (tle.source.State == TrackState.Initial) tl.Add(tle.source);
+                    PrintTracksTbd(tl, existing, notFound, tle.type);
+                }
+                continue;
+            }
+
+            if (tle.needSearch)
+            {
+                Console.WriteLine($"{tle.type} download: {tle.source.ToString(true)}, searching..");
+
+                var responseData = new ResponseData();
+
+                if (tle.type == ListType.Album)
+                {
+                    await InitClientAndUpdateIfNeeded();
+                    tle.list = await GetAlbumDownloads(tle.source, responseData);
+                }
+                else if (tle.type == ListType.Aggregate)
+                {
+                    await InitClientAndUpdateIfNeeded();
+                    tle.list[0] = await GetAggregateTracks(tle.source, responseData);
+                    if (Config.skipExisting)
                     {
-                        source = new Track(source) { TrackState = Track.State.Failed, FailureReason = nameof(FailureReasons.NoSuitableFileFound) };
-                        trackLists.SetSource(source, i);
+                        for (int j = 0; j < tle.list.Count; j++)
+                            existing.AddRange(DoSkipExisting(tle.list[0], print: i == 0 && j == 0));
                     }
                 }
-                else if (type == TrackLists.ListType.Aggregate)
+                else if (tle.type == ListType.AlbumAggregate)
                 {
-                    list[0] = await GetUniqueRelatedTracks(source);
-                    if (list[0].Count == 0)
-                    {
-                        source = new Track(source) { TrackState = Track.State.Failed, FailureReason = nameof(FailureReasons.NoSuitableFileFound) };
-                        trackLists.SetSource(source, i);
-                    }
+                    await InitClientAndUpdateIfNeeded();
+                    var res = await GetAggregateAlbums(tle.source, responseData);
+
+                    foreach (var item in res)
+                        trackLists.AddEntry(new TrackListEntry(item, ListType.Album, tle.source, false, true));
+
+                    continue;
+                }
+
+                if (tle.list.Count == 0 || !tle.list.Any(x => x.Count > 0))
+                {
+                    string lockedFilesStr = responseData.lockedFilesCount > 0 ? $" (Found {responseData.lockedFilesCount} locked files)" : "";
+                    Console.WriteLine($"No results.{lockedFilesStr}");
+                    tle.source.State = TrackState.Failed;
+                    tle.source.FailureReason = FailureReason.NoSuitableFileFound;
+
+                    if (i < trackLists.lists.Count - 1) Console.WriteLine();
+                    continue;
                 }
             }
 
-            if (skipExisting && list != null)
+            if (Config.PrintResults)
             {
-                existing = DoSkipExisting(list[0], print: i==0, useCache: trackLists.lists.Count > 1);
-                foreach (var tracks in list.Skip(1)) DoSkipExisting(tracks, false, useCache: trackLists.lists.Count > 1);
+                await PrintResults(tle, existing, notFound);
+                continue;
             }
 
             m3uEditor.Update();
 
-            if (list != null && (!interactiveMode || debugPrintTracks))
+            if (tle.type != ListType.Album && !Config.interactiveMode)
             {
-                PrintTracksTbd(list[0].Where(t => t.TrackState == Track.State.Initial).ToList(), existing, notFound, type);
+                PrintTracksTbd(tle.list[0].Where(t => t.State == TrackState.Initial).ToList(), existing, notFound, tle.type);
             }
 
-            if (debugPrintTracks || list?.Count == 0 || list?[0].Count == 0)
+            if (notFound.Count + existing.Count >= tle.list.Sum(x => x.Count))
             {
                 if (i < trackLists.lists.Count - 1) Console.WriteLine();
                 continue;
             }
 
-            if (type == TrackLists.ListType.Normal)
+            await InitClientAndUpdateIfNeeded();
+
+            if (tle.type == ListType.Normal)
             {
-                await TracksDownloadNormal(list[0]);
+                await TracksDownloadNormal(tle);
             }
-            else if (type == TrackLists.ListType.Album && list != null)
+            else if (tle.type == ListType.Album)
             {
-                await TracksDownloadAlbum(list, albumArtOnly);
+                await TracksDownloadAlbum(tle);
             }
-            else if (type == TrackLists.ListType.Aggregate)
+            else if (tle.type == ListType.Aggregate)
             {
-                await TracksDownloadNormal(list[0]);
+                await TracksDownloadNormal(tle);
             }
 
             if (i < trackLists.lists.Count - 1)
@@ -1400,69 +277,62 @@ static class Program
             }
         }
 
-        if (!debugDisableDownload && trackLists.CombinedTrackList().Count > 1)
+        if (!Config.DoNotDownload && (trackLists.lists.Count > 0 || trackLists.Flattened(false, false).Skip(1).Any()))
         {
             PrintComplete();
         }
     }
 
 
-    static void PreprocessTrackList(TrackLists trackLists)
+    static async Task PrintResults(TrackListEntry tle, List<Track> existing, List<Track> notFound)
     {
-        for (int k = 0; k < trackLists.lists.Count; k++)
+        await InitClientAndUpdateIfNeeded();
+
+        if (tle.type == ListType.Normal)
         {
-            var (list, type, source) = trackLists.lists[k];
-            trackLists.lists[k] = (list, type, PreprocessTrack(source));
-            foreach (var ls in list)
+            await SearchAndPrintResults(tle.list[0]);
+        }
+        else if (tle.type == ListType.Aggregate)
+        {
+            Console.WriteLine(new string('-', 60));
+            Console.WriteLine($"Results for aggregate {tle.source.ToString(true)}:");
+            PrintTracksTbd(tle.list[0].Where(t => t.State == TrackState.Initial).ToList(), existing, notFound, tle.type);
+        }
+        else if (tle.type == ListType.Album)
+        {
+            Console.WriteLine(new string('-', 60));
+            Console.WriteLine($"Results for album {tle.source.ToString(true)}:");
+
+            if (tle.list.Count > 0 && tle.list[0].Count > 0)
             {
-                for (int i = 0; i < ls.Count; i++)
+                if (!Config.noBrowseFolder)
+                    Console.WriteLine("[Skipped full folder retrieval]");
+
+                foreach (var ls in tle.list)
                 {
-                    ls[i] = PreprocessTrack(ls[i]);
+                    PrintAlbum(ls);
+
+                    if (!Config.printOption.HasFlag(PrintOption.Full))
+                        break;
                 }
             }
+            else
+            {
+                Console.WriteLine("No results.");
+            }
         }
     }
 
 
-    static Track PreprocessTrack(Track track)
-    {
-        if (removeFt)
-        {
-            track.Title = track.Title.RemoveFt();
-            track.Artist = track.Artist.RemoveFt();
-        }
-        if (removeBrackets)
-        {
-            track.Title = track.Title.RemoveSquareBrackets();
-        }
-        if (regexToReplace.Title + regexToReplace.Artist + regexToReplace.Album != "")
-        {
-            track.Title = Regex.Replace(track.Title, regexToReplace.Title, regexReplaceBy.Title);
-            track.Artist = Regex.Replace(track.Artist, regexToReplace.Artist, regexReplaceBy.Artist);
-            track.Album = Regex.Replace(track.Album, regexToReplace.Album, regexReplaceBy.Album);
-        }
-        if (artistMaybeWrong)
-        {
-            track.ArtistMaybeWrong = true;
-        }
-
-        track.Artist = track.Artist.Trim();
-        track.Album = track.Album.Trim();
-        track.Title = track.Title.Trim();
-
-        return track;
-    }
-
-
     static void PrintComplete()
     {
-        var ls = trackLists.CombinedTrackList();
+        var ls = trackLists.Flattened(true, true);
         int successes = 0, fails = 0;
         foreach (var x in ls)
         {
-            if (x.TrackState == Track.State.Downloaded)
+            if (x.State == TrackState.Downloaded)
                 successes++;
-            else if (x.TrackState == Track.State.Failed)
+            else if (x.State == TrackState.Failed)
                 fails++;
         }
         if (successes + fails > 1)
@@ -1470,118 +340,130 @@ static class Program
     }
 
 
-    static void PrintTracksTbd(List<Track> tracks, List<Track> existing, List<Track> notFound, TrackLists.ListType type)
+    static void PrintTracksTbd(List<Track> toBeDownloaded, List<Track> existing, List<Track> notFound, ListType type)
     {
-        if (type == TrackLists.ListType.Normal && !debugPrintTracks && tracks.Count == 1 && existing.Count + notFound.Count == 0)
+        if (type == ListType.Normal && !Config.PrintTracks && toBeDownloaded.Count == 1 && existing.Count + notFound.Count == 0)
             return;
 
         string notFoundLastTime = notFound.Count > 0 ? $"{notFound.Count} not found" : "";
         string alreadyExist = existing.Count > 0 ? $"{existing.Count} already exist" : "";
-        notFoundLastTime = alreadyExist != "" && notFoundLastTime != "" ? ", " + notFoundLastTime : notFoundLastTime;
-        string skippedTracks = alreadyExist + notFoundLastTime != "" ? $" ({alreadyExist}{notFoundLastTime})" : "";
+        notFoundLastTime = alreadyExist.Length > 0 && notFoundLastTime.Length > 0 ? ", " + notFoundLastTime : notFoundLastTime;
+        string skippedTracks = alreadyExist.Length + notFoundLastTime.Length > 0 ? $" ({alreadyExist}{notFoundLastTime})" : "";
+        bool full = Config.printOption.HasFlag(PrintOption.Full);
 
-        Console.WriteLine($"Downloading {tracks.Count(x => !x.IsNotAudio)} tracks{skippedTracks}");
+        if (type == ListType.Normal || skippedTracks.Length > 0)
+            Console.WriteLine($"Downloading {toBeDownloaded.Count(x => !x.IsNotAudio)} tracks{skippedTracks}");
 
-        if (type != TrackLists.ListType.Album)
+        if (toBeDownloaded.Count > 0)
         {
-            if (tracks.Count > 0)
-            {
-                bool showAll = type != TrackLists.ListType.Normal || debugPrintTracks;
-                PrintTracks(tracks, showAll ? int.MaxValue : 10, debugPrintTracksFull, infoFirst: debugPrintTracks);
-                if (debugPrintTracksFull && (existing.Count > 0 || notFound.Count > 0))
-                    Console.WriteLine("\n-----------------------------------------------\n");
-            }
-        }
-        else if (!interactiveMode && tracks.Count > 0 && !tracks[0].Downloads.IsEmpty)
-        {
-            var response = tracks[0].Downloads.First().Value.Item1;
-            string userInfo = $"{response.Username} ({((float)response.UploadSpeed / (1024 * 1024)):F3}MB/s)";
-            var (parents, props) = FolderInfo(tracks.SelectMany(x => x.Downloads.Select(d => d.Value.Item2)));
+            bool showAll = type != ListType.Normal || Config.PrintTracks || Config.PrintResults;
+            PrintTracks(toBeDownloaded, showAll ? int.MaxValue : 10, full, infoFirst: Config.PrintTracks);
 
-            Console.WriteLine();
-            WriteLine($"User  : {userInfo}\nFolder: {parents}\nProps : {props}", ConsoleColor.White);
-            PrintTracks(tracks.Where(t => t.TrackState == Track.State.Initial).ToList(), pathsOnly: true, showAncestors: true, showUser: false);
-            Console.WriteLine();
+            if (full && (existing.Count > 0 || notFound.Count > 0))
+                Console.WriteLine("\n-----------------------------------------------\n");
         }
 
-        if (debugPrintTracks)
+        if (Config.PrintTracks)
         {
             if (existing.Count > 0)
             {
                 Console.WriteLine($"\nThe following tracks already exist:");
-                PrintTracks(existing, fullInfo: debugPrintTracksFull, infoFirst: debugPrintTracks);
+                PrintTracks(existing, fullInfo: full, infoFirst: Config.PrintTracks);
             }
             if (notFound.Count > 0)
             {
-                Console.WriteLine($"\nThe following tracks were not found during the last run:");
-                PrintTracks(notFound, fullInfo: debugPrintTracksFull, infoFirst: debugPrintTracks);
+                Console.WriteLine($"\nThe following tracks were not found during a prior run:");
+                PrintTracks(notFound, fullInfo: full, infoFirst: Config.PrintTracks);
             }
         }
     }
 
 
-    static List<Track> DoSkipExisting(List<Track> tracks, bool print, bool useCache)
+    static void PrintAlbum(List<Track> albumTracks, bool retrieveAll = false)
+    {
+        if (albumTracks.Count == 0 && albumTracks[0].Downloads.IsEmpty)
+            return;
+
+        var response = albumTracks[0].Downloads.First().Value.Item1;
+        string userInfo = $"{response.Username} ({((float)response.UploadSpeed / (1024 * 1024)):F3}MB/s)";
+        var (parents, props) = FolderInfo(albumTracks.SelectMany(x => x.Downloads.Select(d => d.Value.Item2)));
+
+        Console.WriteLine();
+        WriteLine($"User  : {userInfo}\nFolder: {parents}\nProps : {props}", ConsoleColor.White);
+        PrintTracks(albumTracks.Where(t => t.State == TrackState.Initial).ToList(), pathsOnly: true, showAncestors: true, showUser: false);
+        Console.WriteLine();
+    }
+
+
+    static List<Track> DoSkipExisting(List<Track> tracks, bool print)
     {
         var existing = new Dictionary<Track, string>();
 
-        if (skipMode == SkipMode.M3u)
+        bool fileBasedSkip = (int)Config.skipMode < 4;
+
+        if (!(fileBasedSkip && Config.musicDir.Length > 0 && Config.outputFolder.StartsWith(Config.musicDir, StringComparison.OrdinalIgnoreCase)))
         {
-            existing = SkipExistingM3u(tracks);
+            var d = ExistingCheckers.Registry.SkipExisting(tracks, Config.outputFolder, Config.necessaryCond, m3uEditor, Config.skipMode);
+            d.ToList().ForEach(x => existing.TryAdd(x.Key, x.Value));
         }
-        else
+        if (Config.musicDir.Length > 0 && System.IO.Directory.Exists(Config.musicDir))
         {
-            if (!(musicDir != "" && outputFolder.StartsWith(musicDir, StringComparison.OrdinalIgnoreCase)) && System.IO.Directory.Exists(outputFolder))
-            {
-                var d = SkipExisting(tracks, outputFolder, necessaryCond, skipMode, useCache);
-                d.ToList().ForEach(x => existing.TryAdd(x.Key, x.Value));
-            }
-            if (musicDir != "" && System.IO.Directory.Exists(musicDir))
-            {
-                if (print) Console.WriteLine($"Checking if tracks exist in library..");
-                var d = SkipExisting(tracks, musicDir, necessaryCond, skipMode, useCache);
-                d.ToList().ForEach(x => existing.TryAdd(x.Key, x.Value));
-            }
-            else if (musicDir != "" && !System.IO.Directory.Exists(musicDir))
-                if (print) Console.WriteLine($"Music dir does not exist: {musicDir}");
+            if (print) Console.WriteLine($"Checking if tracks exist in library..");
+            var d = ExistingCheckers.Registry.SkipExisting(tracks, Config.musicDir, Config.necessaryCond, m3uEditor, Config.skipModeMusicDir);
+            d.ToList().ForEach(x => existing.TryAdd(x.Key, x.Value));
+        }
+        else if (Config.musicDir.Length > 0 && !System.IO.Directory.Exists(Config.musicDir))
+        {
+            if (print) Console.WriteLine($"Music dir does not exist: {Config.musicDir}");
         }
 
         return existing.Select(x => x.Key).ToList();
     }
 
 
-    static (List<Track>, Track) SkipNotFound(List<Track> tracks, Track source)
+    static List<Track> DoSkipNotFound(List<Track> tracks)
     {
         List<Track> notFound = new List<Track>();
-        if (m3uEditor.HasFail(source, out string? reason) && reason == nameof(FailureReasons.NoSuitableFileFound))
-        {
-            notFound.Add(source);
-            source = new Track(source) { TrackState = Track.State.NotFoundLastTime };
-        }
         for (int i = tracks.Count - 1; i >= 0; i--)
         {
-            if (m3uEditor.HasFail(tracks[i], out reason) && reason == nameof(FailureReasons.NoSuitableFileFound))
+            if (SetNotFoundLastTime(tracks[i]))
             {
                 notFound.Add(tracks[i]);
-                tracks[i] = new Track(tracks[i]) { TrackState = Track.State.NotFoundLastTime };
             }
         }
-        return (notFound, source);
+        return notFound;
     }
 
 
-    static async Task TracksDownloadNormal(List<Track> tracks)
+    static bool SetNotFoundLastTime(Track track)
     {
-        SemaphoreSlim semaphore = new SemaphoreSlim(maxConcurrentProcesses);
+        if (m3uEditor.TryGetPreviousRunResult(track, out var prevTrack))
+        {
+            if (prevTrack.FailureReason == FailureReason.NoSuitableFileFound || prevTrack.State == TrackState.NotFoundLastTime)
+            {
+                track.State = TrackState.NotFoundLastTime;
+                return true;
+            }
+        }
+        return false;
+    }
+
+
+    static async Task TracksDownloadNormal(TrackListEntry tle)
+    {
+        var tracks = tle.list[0];
+
+        SemaphoreSlim semaphore = new SemaphoreSlim(Config.concurrentProcesses);
 
         var copy = new List<Track>(tracks);
         var downloadTasks = copy.Select(async (track, index) =>
         {
-            if (track.TrackState == Track.State.Exists || track.TrackState == Track.State.NotFoundLastTime)
+            if (track.State == TrackState.AlreadyExists || (track.State == TrackState.NotFoundLastTime && Config.skipNotFound))
                 return;
 
             await semaphore.WaitAsync();
 
-            int tries = unknownErrorRetries;
+            int tries = Config.unknownErrorRetries;
             string savedFilePath = "";
 
             while (tries > 0)
@@ -1596,13 +478,17 @@ static class Program
                 catch (Exception ex)
                 {
                     WriteLine($"Exception thrown: {ex}", debugOnly: true);
-                    if (!client.State.HasFlag(SoulseekClientStates.LoggedIn))
+                    if (!IsConnectedAndLoggedIn())
                     {
                         continue;
                     }
-                    else if (ex is SearchAndDownloadException)
+                    else if (ex is SearchAndDownloadException sdEx)
                     {
-                        lock (trackLists) { tracks[index] = new Track(track) { TrackState = Track.State.Failed, FailureReason = ex.Message }; }
+                        lock (trackLists)
+                        {
+                            tracks[index].State = TrackState.Failed;
+                            tracks[index].FailureReason = sdEx.reason;
+                        }
                     }
                     else
                     {
@@ -1615,17 +501,21 @@ static class Program
                 break;
             }
 
-            if (savedFilePath != "")
+            if (savedFilePath.Length > 0)
             {
-                lock (trackLists) { tracks[index] = new Track(track) { TrackState = Track.State.Downloaded, DownloadPath = savedFilePath }; }
+                lock (trackLists) 
+                {
+                    tracks[index].State = TrackState.Downloaded;
+                    tracks[index].DownloadPath = savedFilePath; 
+                }
 
-                if (removeTracksFromSource)
+                if (Config.removeTracksFromSource)
                 {
                     try
                     {
-                        await RemoveTrackFromSource(track);
+                        await extractor.RemoveTrackFromSource(track);
                     }
-                    catch (Exception ex) 
+                    catch (Exception ex)
                     {
                         WriteLine($"\n{ex.Message}\n{ex.StackTrace}\n", ConsoleColor.DarkYellow, true);
                     }
@@ -1634,9 +524,9 @@ static class Program
 
             m3uEditor.Update();
 
-            if (onComplete != "")
+            if (Config.onComplete.Length > 0)
             {
-                OnComplete(onComplete, tracks[index]);
+                OnComplete(Config.onComplete, tracks[index]);
             }
 
             semaphore.Release();
@@ -1646,81 +536,122 @@ static class Program
     }
 
 
-    static async Task TracksDownloadAlbum(List<List<Track>> list, bool imagesOnly) // bad
+    static async Task TracksDownloadAlbum(TrackListEntry tle) // this is shit
     {
+        var list = tle.list;
         var dlFiles = new ConcurrentDictionary<string, bool>();
         var dlAdditionalImages = new ConcurrentDictionary<string, bool>();
+        var retrievedFolders = new HashSet<string>();
         var tracks = new List<Track>();
         bool downloadingImages = false;
         bool albumDlFailed = false;
-        var listRef = list; 
+        var listRef = list;
+        string savedOutputFolder = Config.outputFolder;
 
-        void prepareImageDownload()
+        var curAlbumArtOption = Config.albumArtOption == AlbumArtOption.MostLargest ? AlbumArtOption.Most : Config.albumArtOption;
+
+        void prepareImageDownload(AlbumArtOption option)
         {
-            var albumArtList = list.Select(tracks => tracks.Where(t => Utils.IsImageFile(t.Downloads.First().Value.Item2.Filename))).Where(tracks => tracks.Any());
-            if (albumArtOption == "largest")
+            var albumArtList = list
+                //.Where(tracks => tracks)
+                .Select(tracks => tracks.Where(t => Utils.IsImageFile(t.Downloads.First().Value.Item2.Filename)))
+                .Where(tracks => tracks.Any());
+
+            if (option == AlbumArtOption.Largest)
             {
-                list = albumArtList // shitty shortcut
+                list = albumArtList
                     .OrderByDescending(tracks => tracks.Select(t => t.Downloads.First().Value.Item2.Size).Max() / 1024 / 100)
                     .ThenByDescending(tracks => tracks.First().Downloads.First().Value.Item1.UploadSpeed / 1024 / 300)
                     .ThenByDescending(tracks => tracks.Select(t => t.Downloads.First().Value.Item2.Size).Sum() / 1024 / 100)
                     .Select(x => x.ToList()).ToList();
             }
-            else if (albumArtOption == "most")
+            else if (option == AlbumArtOption.Most)
             {
-                list = albumArtList // shitty shortcut
+                list = albumArtList
                     .OrderByDescending(tracks => tracks.Count())
                     .ThenByDescending(tracks => tracks.First().Downloads.First().Value.Item1.UploadSpeed / 1024 / 300)
                     .ThenByDescending(tracks => tracks.Select(t => t.Downloads.First().Value.Item2.Size).Sum() / 1024 / 100)
                     .Select(x => x.ToList()).ToList();
             }
-            downloadingImages = true;
         }
 
-        if (imagesOnly)
+        bool needImageDownload(AlbumArtOption option)
         {
-            prepareImageDownload();
+            bool need = true;
+
+            if (option == AlbumArtOption.Most)
+            {
+                need = dlFiles.Keys.Count(x => Utils.IsImageFile(x) && File.Exists(x)) < list[0].Count;
+            }
+            else if (option == AlbumArtOption.Largest)
+            {
+                long curMax = dlFiles.Keys.Where(x => Utils.IsImageFile(x) && File.Exists(x)).Max(x => new FileInfo(x).Length);
+                need = curMax < list[0].Max(t => t.Downloads.First().Value.Item2.Size) - 1024 * 50;
+            }
+
+            return need;
+        }
+
+        if (Config.albumArtOnly)
+        {
+            prepareImageDownload(curAlbumArtOption);
+            downloadingImages = true;
         }
 
         int idx = -1;
         while (list.Count > 0)
         {
             idx++;
-            albumDlFailed = false;
-            tracks = interactiveMode ? InteractiveModeAlbum(list) : list[0];
-
-            if (!downloadingImages && tracks.All(t => t.TrackState != Track.State.Initial || (!interactiveMode && t.IsNotAudio)))
-                goto imgDl;
-            if (list.Count <= 1 && tracks.All(t => t.TrackState != Track.State.Initial))
-                goto imgDl;
-
             mainLoopCts = new CancellationTokenSource();
-            albumCommonPath = Utils.GreatestCommonPath(tracks.SelectMany(x => x.Downloads.Select(y => y.Value.Item2.Filename)), dirsep: '\\');
-            SemaphoreSlim semaphore = new SemaphoreSlim(maxConcurrentProcesses);
-            var copy = new List<Track>(tracks);
+            albumDlFailed = false;
 
-            if (!interactiveMode && idx > 0 && tracks.Count > 0 && !tracks[0].Downloads.IsEmpty)
+            if (Config.interactiveMode)
+                tracks = await InteractiveModeAlbum(list, !downloadingImages, retrievedFolders);
+            else
+                tracks = list[0];
+
+            soulseekFolderPathPrefix = GetCommonPathPrefix(tracks);
+
+            if (tle.placeInSubdir && (!downloadingImages || idx == 0))
             {
-                var response = tracks[0].Downloads.First().Value.Item1;
-                string userInfo = $"{response.Username} ({((float)response.UploadSpeed / (1024 * 1024)):F3}MB/s)";
-                var (parents, props) = FolderInfo(tracks.SelectMany(x => x.Downloads.Select(d => d.Value.Item2)));
-
-                Console.WriteLine();
-                WriteLine($"User  : {userInfo}\nFolder: {parents}\nProps : {props}", ConsoleColor.White);
-                PrintTracks(tracks.Where(t => t.TrackState == Track.State.Initial).ToList(), pathsOnly: true, showAncestors: true, showUser: false);
-                Console.WriteLine();
+                Config.outputFolder = Path.Join(savedOutputFolder, Utils.GetBaseNameSlsk(soulseekFolderPathPrefix));
             }
 
+            if (!downloadingImages)
+            {
+                if (!Config.noBrowseFolder && !Config.interactiveMode && !retrievedFolders.Contains(soulseekFolderPathPrefix))
+                {
+                    Console.WriteLine("Getting all files in folder...");
+                    var response = tracks[0].Downloads.First().Value.Item1;
+                    await CompleteFolder(tracks, response, soulseekFolderPathPrefix);
+                    retrievedFolders.Add(soulseekFolderPathPrefix);
+                }
+            }
+
+            if (!Config.interactiveMode)
+                PrintAlbum(tracks);
+
+            if (!downloadingImages)
+            {
+                if (tracks.All(t => t.State != TrackState.Initial || (!Config.interactiveMode && t.IsNotAudio)))
+                    goto imgDl;
+                if (list.Count <= 1 && tracks.All(t => t.State != TrackState.Initial))
+                    goto imgDl;
+            }
+
+            var semaphore = new SemaphoreSlim(Config.concurrentProcesses);
+            var copy = new List<Track>(tracks);
+
             try
             {
                 var downloadTasks = copy.Select(async (track, index) =>
                 {
-                    if (track.TrackState != Track.State.Initial)
+                    if (track.State != TrackState.Initial)
                         return;
 
                     await semaphore.WaitAsync(mainLoopCts.Token);
-                    
-                    int tries = unknownErrorRetries;
+
+                    int tries = Config.unknownErrorRetries;
                     string savedFilePath = "";
 
                     while (tries > 0)
@@ -1734,20 +665,19 @@ static class Program
                         }
                         catch (Exception ex)
                         {
-                            if (!client.State.HasFlag(SoulseekClientStates.LoggedIn))
+                            if (!IsConnectedAndLoggedIn())
                             {
                                 continue;
                             }
-                            else if (ex is SearchAndDownloadException)
+                            else if (ex is SearchAndDownloadException sdEx)
                             {
                                 lock (trackLists)
                                 {
-                                    tracks[index] = new Track(track) { TrackState = Track.State.Failed, FailureReason = ex.Message };
-                                    if (downloadingImages)
-                                        ReplaceTrack(listRef, track, tracks[index]); // shitty shortcut
+                                    tracks[index].State = TrackState.Failed;
+                                    tracks[index].FailureReason = sdEx.reason;
                                 }
 
-                                if (!albumIgnoreFails)
+                                if (!Config.albumIgnoreFails)
                                 {
                                     mainLoopCts.Cancel();
                                     foreach (var (key, dl) in downloads)
@@ -1771,26 +701,26 @@ static class Program
                         }
 
                         break;
-                    } 
+                    }
 
-                    if (savedFilePath != "")
+                    if (savedFilePath.Length > 0)
                     {
                         dlFiles.TryAdd(savedFilePath, true);
 
                         lock (trackLists)
                         {
-                            tracks[index] = new Track(track) { TrackState = Track.State.Downloaded, DownloadPath = savedFilePath };
+                            tracks[index].State = TrackState.Downloaded;
+                            tracks[index].DownloadPath = savedFilePath;
                             if (downloadingImages)
                             {
                                 dlAdditionalImages.TryAdd(savedFilePath, true);
-                                ReplaceTrack(listRef, track, tracks[index]); // shitty shortcut
                             }
                         }
                     }
 
-                    if (onComplete != "")
+                    if (Config.onComplete.Length > 0)
                     {
-                        OnComplete(onComplete, tracks[index]);
+                        OnComplete(Config.onComplete, tracks[index]);
                     }
 
                     semaphore.Release();
@@ -1800,7 +730,7 @@ static class Program
             }
             catch (OperationCanceledException)
             {
-                if (!albumIgnoreFails)
+                if (!Config.albumIgnoreFails)
                 {
                     if (!downloadingImages)
                         albumDlFailed = true;
@@ -1814,28 +744,32 @@ static class Program
             }
 
         imgDl:
-            if (!downloadingImages && !albumDlFailed && albumArtOption != "")
-            {
-                prepareImageDownload();
-                bool needImageDl = true;
+            bool needDownloadAgain = Config.albumArtOption == AlbumArtOption.MostLargest && curAlbumArtOption == AlbumArtOption.Most;
 
-                if (!interactiveMode && list.Count > 0)
+            if ((!downloadingImages || needDownloadAgain) && !albumDlFailed && Config.albumArtOption != AlbumArtOption.Default)
+            {
+                if (curAlbumArtOption == AlbumArtOption.Most && downloadingImages && Config.albumArtOption == AlbumArtOption.MostLargest)
                 {
-                    if (albumArtOption == "most")
-                    {
-                        needImageDl = dlFiles.Keys.Count(x => Utils.IsImageFile(x) && File.Exists(x)) < list[0].Count;
-                    }
-                    else if (albumArtOption == "largest")
-                    {
-                        long curMax = dlFiles.Keys.Where(x => Utils.IsImageFile(x) && File.Exists(x)).Max(x => new FileInfo(x).Length);
-                        needImageDl = curMax < list[0].Max(t => t.Downloads.First().Value.Item2.Size) - 1024 * 50;
-                    }
+                    curAlbumArtOption = AlbumArtOption.Largest;
                 }
-                
-                if (needImageDl)
+
+                prepareImageDownload(curAlbumArtOption);
+
+                if (Config.interactiveMode || needImageDownload(curAlbumArtOption))
                 {
+                    downloadingImages = true;
                     continue;
                 }
+                else if (Config.albumArtOption == AlbumArtOption.MostLargest && curAlbumArtOption == AlbumArtOption.Most)
+                {
+                    curAlbumArtOption = AlbumArtOption.Largest;
+                    prepareImageDownload(curAlbumArtOption);
+                    if (Config.interactiveMode || needImageDownload(curAlbumArtOption))
+                    {
+                        downloadingImages = true;
+                        continue;
+                    }
+                }
             }
 
             break;
@@ -1843,27 +777,21 @@ static class Program
 
         ApplyNamingFormatsNonAudio(listRef);
         m3uEditor.Update();
-        albumCommonPath = "";
+        soulseekFolderPathPrefix = "";
+        Config.outputFolder = savedOutputFolder;
     }
 
 
-    static void ReplaceTrack(List<List<Track>> list, Track oldTrack, Track newTrack) // shitty shortcut
+    static string GetCommonPathPrefix(List<Track> tracks)
     {
-        foreach (var sublist in list)
-        {
-            for (int i = 0; i < sublist.Count; i++)
-            {
-                if (sublist[i].Equals(oldTrack))
-                {
-                    sublist[i] = newTrack;
-                    return;
-                }
-            }
-        }
+        if (tracks.Count == 1)
+            return Utils.GetDirectoryNameSlsk(tracks.First().Downloads.First().Value.Item2.Filename);
+        else
+            return Utils.GreatestCommonPath(tracks.SelectMany(x => x.Downloads.Select(y => y.Value.Item2.Filename)), dirsep: '\\');
     }
 
 
-    static List<Track> InteractiveModeAlbum(List<List<Track>> list)
+    static async Task<List<Track>> InteractiveModeAlbum(List<List<Track>> list, bool retrieveFolder, HashSet<string> retrievedFolders)
     {
         int aidx = 0;
         static string interactiveModeLoop()
@@ -1891,12 +819,20 @@ static class Program
             var tracks = list[aidx];
             var response = tracks[0].Downloads.First().Value.Item1;
 
+            var folder = GetCommonPathPrefix(tracks);
+            if (retrieveFolder && !Config.noBrowseFolder && !retrievedFolders.Contains(folder))
+            {
+                Console.WriteLine("Getting all files in folder...");
+                await CompleteFolder(tracks, response, folder);
+                retrievedFolders.Add(folder);
+            }
+
             string userInfo = $"{response.Username} ({((float)response.UploadSpeed / (1024 * 1024)):F3}MB/s)";
             var (parents, props) = FolderInfo(tracks.SelectMany(x => x.Downloads.Select(d => d.Value.Item2)));
 
             WriteLine($"[{aidx + 1} / {list.Count}]", ConsoleColor.DarkGray);
             WriteLine($"User  : {userInfo}\nFolder: {parents}\nProps : {props}", ConsoleColor.White);
-            PrintTracks(tracks.Where(t => t.TrackState == Track.State.Initial).ToList(), pathsOnly: true, showAncestors: true, showUser: false);
+            PrintTracks(tracks, pathsOnly: true, showAncestors: true, showUser: false);
 
             string userInput = interactiveModeLoop();
             switch (userInput)
@@ -1910,7 +846,7 @@ static class Program
                 case "c":
                     return new List<Track>();
                 case "q":
-                    interactiveMode = false;
+                    Config.interactiveMode = false;
                     list.RemoveAt(aidx);
                     return tracks;
                 case "":
@@ -1940,13 +876,13 @@ static class Program
         else
             totalLengthFormatted = string.Format("{0:D2}:{1:D2}", totalTimeSpan.Minutes, totalTimeSpan.Seconds);
 
-        var mostCommonExtension = files.GroupBy(f => GetExtensionSlsk(f.Filename))
+        var mostCommonExtension = files.GroupBy(f => Utils.GetExtensionSlsk(f.Filename))
             .OrderByDescending(g => Utils.IsMusicExtension(g.Key)).ThenByDescending(g => g.Count()).First().Key;
 
         res = $"[{mostCommonExtension.ToUpper()} / {totalLengthFormatted}";
 
         if (modeSampleRate.HasValue)
-            res += $" / {(modeSampleRate.Value/1000.0).Normalize()} kHz";
+            res += $" / {(modeSampleRate.Value / 1000.0).Normalize()} kHz";
 
         if (meanBitrate.HasValue)
             res += $" / {(int)meanBitrate.Value} kbps";
@@ -1955,48 +891,26 @@ static class Program
 
         string gcp;
 
-        if (files.Count() > 1)
+        if (files.Skip(1).Any())
             gcp = Utils.GreatestCommonPath(files.Select(x => x.Filename), '\\').TrimEnd('\\');
         else
-            gcp = GetDirectoryNameSlsk(files.First().Filename);
+            gcp = Utils.GetDirectoryNameSlsk(files.First().Filename);
 
         var discPattern = new Regex(@"^(?i)(dis[c|k]|cd)\s*\d{1,2}$");
         int lastIndex = gcp.LastIndexOf('\\');
         if (lastIndex != -1)
         {
             int secondLastIndex = gcp.LastIndexOf('\\', lastIndex - 1);
-            gcp = secondLastIndex == -1 ? gcp.Substring(lastIndex + 1) : gcp.Substring(secondLastIndex + 1);
+            gcp = secondLastIndex == -1 ? gcp[(lastIndex + 1)..] : gcp[(secondLastIndex + 1)..];
         }
 
         return (gcp, res);
     }
 
 
-    static async Task RemoveTrackFromSource(Track track)
-    {
-        if (inputType == InputType.Spotify && track.URI != "")
-        {
-            await spotifyClient.RemoveTrackFromPlaylist(playlistUri, track.URI);
-        }
-        else if (inputType == InputType.CSV && track.CsvRow != -1)
-        {
-            lock (csvLock)
-            {
-                string[] lines = File.ReadAllLines(csvPath, System.Text.Encoding.UTF8);
-
-                if (lines.Length > track.CsvRow)
-                {
-                    lines[track.CsvRow] = new string(',', Math.Max(0, csvColumnCount - 1));
-                    File.WriteAllLines(csvPath, lines, System.Text.Encoding.UTF8);
-                }
-            }
-        }
-    }
-
-
     static async Task Login(bool random = false, int tries = 3)
     {
-        string user = username, pass = password;
+        string user = Config.username, pass = Config.password;
         if (random)
         {
             var r = new Random();
@@ -2012,13 +926,15 @@ static class Program
             {
                 WriteLine($"Connecting {user}", debugOnly: true);
                 await client.ConnectAsync(user, pass);
-                if (!noModifyShareCount) {
+                if (!Config.noModifyShareCount)
+                {
                     WriteLine($"Setting share count", debugOnly: true);
-                    await client.SetSharedCountsAsync(10, 50);
+                    await client.SetSharedCountsAsync(20, 100);
                 }
                 break;
             }
-            catch (Exception e) {
+            catch (Exception e)
+            {
                 WriteLine($"Exception while logging in: {e}", debugOnly: true);
                 if (!(e is Soulseek.AddressException || e is System.TimeoutException) && --tries == 0)
                     throw;
@@ -2031,977 +947,6 @@ static class Program
     }
 
 
-    static async Task<string> SearchAndDownload(Track track)
-    {
-        Console.ResetColor();
-        ProgressBar? progress = GetProgressBar(displayStyle);
-        var results = new SlDictionary();
-        var fsResults = new SlDictionary();
-        var cts = new CancellationTokenSource();
-        var saveFilePath = "";
-        Task? downloadTask = null;
-        var fsDownloadLock = new object();
-        int fsResultsStarted = 0;
-        int downloading = 0;
-        bool notFound = false;
-        bool searchEnded = false;
-        string fsUser = "";
-        string fsFile = "";
-
-        if (track.Downloads != null) 
-        {
-            results = track.Downloads;
-            goto downloads;
-        }
-
-        RefreshOrPrint(progress, 0, $"Waiting: {track}", false);
-
-        string searchText = $"{track.Artist} {track.Title}".Trim();
-        var removeChars = new string[] { " ", "_", "-" };
-
-        searches.TryAdd(track, new SearchInfo(results, progress));
-
-        void fastSearchDownload()
-        {
-            lock (fsDownloadLock)
-            {
-                if (downloading == 0 && !searchEnded)
-                {
-                    downloading = 1;
-                    var (r, f) = fsResults.MaxBy(x => x.Value.Item1.UploadSpeed).Value;
-                    saveFilePath = GetSavePath(f.Filename);
-                    fsUser = r.Username;
-                    fsFile = f.Filename;
-                    downloadTask = DownloadFile(r, f, saveFilePath, track, progress, cts);
-                }
-            }
-        }
-
-        void responseHandler(SearchResponse r)
-        {
-            if (r.Files.Count > 0)
-            {
-                foreach (var file in r.Files)
-                    results.TryAdd(r.Username + "\\" + file.Filename, (r, file));
-
-                if (fastSearch && !debugDisableDownload && userSuccessCount.GetValueOrDefault(r.Username, 0) > deprioritizeOn)
-                {
-                    var f = r.Files.First();
-
-                    if (r.HasFreeUploadSlot && r.UploadSpeed/1024.0/1024.0 >= fastSearchMinUpSpeed 
-                        && BracketCheck(track, InferTrack(f.Filename, track)) && preferredCond.FileSatisfies(f, track, r))
-                    {
-                        fsResults.TryAdd(r.Username + "\\" + f.Filename, (r, f));
-                        if (Interlocked.Exchange(ref fsResultsStarted, 1) == 0)
-                        {
-                            Task.Delay(fastSearchDelay).ContinueWith(tt => fastSearchDownload());
-                        }
-                    }
-                }
-            }
-        }
-
-        SearchOptions getSearchOptions(int timeout, FileConditions necCond, FileConditions prfCond)
-        {
-            return new SearchOptions(
-                minimumResponseFileCount: 1,
-                minimumPeerUploadSpeed: 1,
-                searchTimeout: searchTimeout,
-                removeSingleCharacterSearchTerms: removeSingleCharacterSearchTerms,
-                responseFilter: (response) =>
-                {
-                    return response.UploadSpeed > 0 && necCond.BannedUsersSatisfies(response);
-                },
-                fileFilter: (file) =>
-                {
-                    return Utils.IsMusicFile(file.Filename) && (necCond.FileSatisfies(file, track, null) || printResultsFull);
-                });
-        }
-
-        void onSearch() => RefreshOrPrint(progress, 0, $"Searching: {track}", true);
-        await RunSearches(track, results, getSearchOptions, responseHandler, cts.Token, onSearch);
-
-        searches.TryRemove(track, out _);
-        searchEnded = true;
-        lock (fsDownloadLock) { }
-
-        if (downloading==0 && results.IsEmpty && !useYtdlp)
-        {
-            notFound = true;
-        }
-        else if (downloading==1)
-        {
-            try 
-            {
-                if (downloadTask == null || downloadTask.IsFaulted || downloadTask.IsCanceled)
-                    throw new TaskCanceledException();
-                await downloadTask;
-                userSuccessCount.AddOrUpdate(fsUser, 1, (k, v) => v + 1);
-            }
-            catch
-            {
-                saveFilePath = "";
-                downloading = 0;
-                results.TryRemove(fsUser + "\\" + fsFile, out _);
-                userSuccessCount.AddOrUpdate(fsUser, -1, (k, v) => v - 1);
-            }
-        }
-
-        cts.Dispose();
-
-    downloads:
-
-        if (debugDisableDownload && results.IsEmpty)
-        {
-            WriteLine($"No results", ConsoleColor.Yellow);
-            return "";
-        }
-        else if (downloading==0 && !results.IsEmpty)
-        {
-            var random = new Random();
-            var orderedResults = OrderedResults(results, track, true);
-
-            if (debugDisableDownload)
-            {
-                int count = 0;
-                Console.WriteLine();
-                foreach (var (response, file) in orderedResults) {
-                    Console.WriteLine(DisplayString(track, file, response,
-                        printResultsFull ? necessaryCond : null, printResultsFull ? preferredCond : null, 
-                        fullpath: printResultsFull, infoFirst: true, showSpeed: printResultsFull));
-                    count += 1;
-                }
-                WriteLine($"Total: {count}\n", ConsoleColor.Yellow);
-                return "";
-            }
-
-            async Task<bool> process(SlResponse response, SlFile file)
-            {
-                saveFilePath = GetSavePath(file.Filename);
-                try
-                {
-                    downloading = 1;
-                    await DownloadFile(response, file, saveFilePath, track, progress);
-                    userSuccessCount.AddOrUpdate(response.Username, 1, (k, v) => v + 1);
-                    return true;
-                }
-                catch (Exception e)
-                {
-                    downloading = 0;
-                    if (!client.State.HasFlag(SoulseekClientStates.LoggedIn))
-                        throw;
-                    userSuccessCount.AddOrUpdate(response.Username, -1, (k, v) => v - 1);
-                    if (--maxRetriesPerTrack <= 0)
-                    {
-                        RefreshOrPrint(progress, 0, $"Out of download retries: {track}", true);
-                        WriteLine("Last error was: " + e.Message, ConsoleColor.DarkYellow, true);
-                        throw new SearchAndDownloadException(nameof(FailureReasons.OutOfDownloadRetries));
-                    }
-                    return false;
-                }
-            }
-
-            // the first result is usually fine, no need to sort the entire sequence
-            var fr = orderedResults.First();
-            bool success = await process(fr.response, fr.file); 
-
-            if (!success)
-            {
-                fr = orderedResults.Skip(1).FirstOrDefault();
-                if (fr != default && userSuccessCount.GetValueOrDefault(fr.response.Username, 0) > ignoreOn)
-                {
-                    success = await process(fr.response, fr.file);
-                }
-
-                if (!success && fr != default)
-                {
-                    foreach (var (response, file) in orderedResults.Skip(2))
-                    {
-                        if (userSuccessCount.GetValueOrDefault(response.Username, 0) <= ignoreOn)
-                            continue;
-                        success = await process(response, file);
-                        if (success) break;
-                    }
-                }
-            }
-        }
-
-        if (downloading == 0 && useYtdlp)
-        {
-            notFound = false;
-            try 
-            {
-                RefreshOrPrint(progress, 0, $"yt-dlp search: {track}", true);
-                var ytResults = await YouTube.YtdlpSearch(track);
-
-                if (ytResults.Count > 0)
-                {
-                    foreach (var (length, id, title) in ytResults)
-                    {
-                        if (necessaryCond.LengthToleranceSatisfies(length, track.Length))
-                        {
-                            string saveFilePathNoExt = GetSavePathNoExt(title);
-                            downloading = 1;
-                            RefreshOrPrint(progress, 0, $"yt-dlp download: {track}", true);
-                            saveFilePath = await YouTube.YtdlpDownload(id, saveFilePathNoExt, ytdlpArgument);
-                            RefreshOrPrint(progress, 100, $"Succeded: yt-dlp completed download for {track}", true);
-                            break;
-                        }
-                    }
-                }
-            }
-            catch (Exception e) 
-            {
-                saveFilePath = "";
-                downloading = 0;
-                RefreshOrPrint(progress, 0, $"{e.Message}", true);
-                throw new SearchAndDownloadException(nameof(FailureReasons.NoSuitableFileFound));
-            }
-        }
-
-        if (downloading == 0)
-        {
-            if (notFound)
-            {
-                RefreshOrPrint(progress, 0, $"Not found: {track}", true);
-                throw new SearchAndDownloadException(nameof(FailureReasons.NoSuitableFileFound));
-            }
-            else
-            {
-                RefreshOrPrint(progress, 0, $"All downloads failed: {track}", true);
-                throw new SearchAndDownloadException(nameof(FailureReasons.AllDownloadsFailed));
-            }
-        }
-
-        if (nameFormat != "")
-            saveFilePath = ApplyNamingFormat(saveFilePath, track);
-
-        return saveFilePath;
-    }
-
-
-    public class SearchAndDownloadException : Exception
-    {
-        public SearchAndDownloadException(string text = "") : base(text) { }
-    }
-
-
-    static async Task<List<List<Track>>> GetAlbumDownloads(Track track) // slow
-    {
-        var results = new ConcurrentDictionary<string, (SearchResponse, Soulseek.File)>();
-        SearchOptions getSearchOptions(int timeout, FileConditions nec, FileConditions prf) =>
-            new SearchOptions(
-                minimumResponseFileCount: 1,
-                minimumPeerUploadSpeed: 1,
-                removeSingleCharacterSearchTerms: removeSingleCharacterSearchTerms,
-                searchTimeout: timeout,
-                responseFilter: (response) =>
-                {
-                    return response.UploadSpeed > 0 && nec.BannedUsersSatisfies(response);
-                }
-                //fileFilter: (file) => {
-                //    return FileConditions.StrictString(GetDirectoryNameSlsk(file.Filename), track.ArtistName, ignoreCase: true)
-                //        && FileConditions.StrictString(GetDirectoryNameSlsk(file.Filename), track.Album, ignoreCase: true);
-                //}
-            );
-        void handler(SlResponse r)
-        {
-            if (r.Files.Count > 0)
-            {
-                foreach (var file in r.Files)
-                    results.TryAdd(r.Username + "\\" + file.Filename, (r, file));
-            }
-        }
-        var cts = new CancellationTokenSource();
-
-        await RunSearches(track, results, getSearchOptions, handler, cts.Token);
-
-        string fullPath((SearchResponse r, Soulseek.File f) x) { return x.r.Username + "\\" + x.f.Filename; }
-
-        var orderedResults = OrderedResults(results, track, false, false, albumMode: true);
-
-        if (debugDisableDownload && !debugPrintTracks)
-        {
-            Console.WriteLine();
-            foreach (var (response, file) in orderedResults)
-            {
-                Console.WriteLine(DisplayString(track, file, response,
-                        printResultsFull ? necessaryCond : null, printResultsFull ? preferredCond : null,
-                        fullpath: printResultsFull, infoFirst: true, showSpeed: printResultsFull));
-            }
-            WriteLine($"Total: {orderedResults.Count()}\n", ConsoleColor.Yellow);
-            return default;
-        }
-
-        var groupedLists = orderedResults.GroupBy(x => fullPath(x).Substring(0, fullPath(x).LastIndexOf('\\')));
-        var musicFolders = new List<(string Key, List<(SlResponse response, SlFile file)>)>();
-        var nonMusicFolders = new List<IGrouping<string, (SlResponse response, SlFile file)>>();
-
-        foreach (var group in groupedLists)
-        {
-            if (group.Any(x => Utils.IsMusicFile(x.file.Filename)))
-                musicFolders.Add((group.Key, group.ToList()));
-            else
-                nonMusicFolders.Add(group);
-        }
-
-        var discPattern = new Regex(@"^(?i)(dis[c|k]|cd)\s*\d{1,2}$");
-        if (!discPattern.IsMatch(track.Album))
-        {
-            for (int i = 0; i < musicFolders.Count; i++)
-            {
-                var (folderKey, files) = musicFolders[i];
-                var parentFolderName = GetFileNameSlsk(folderKey);
-                if (discPattern.IsMatch(parentFolderName))
-                {
-                    var parentFolderKey = GetDirectoryNameSlsk(folderKey);
-                    var parentFolderItem = musicFolders.FirstOrDefault(x => x.Key == parentFolderKey);
-                    if (parentFolderItem != default)
-                    {
-                        parentFolderItem.Item2.AddRange(files);
-                        musicFolders.RemoveAt(i);
-                        i--;
-                    }
-                    else
-                        musicFolders[i] = (parentFolderKey, files);
-                }
-            }
-        }
-
-        foreach (var nonMusicFolder in nonMusicFolders)
-        {
-            foreach (var musicFolder in musicFolders)
-            {
-                string x = nonMusicFolder.Key.TrimEnd('\\') + '\\';
-                if (x.StartsWith(musicFolder.Key.TrimEnd('\\') + '\\'))
-                {
-                    musicFolder.Item2.AddRange(nonMusicFolder);
-                    break;
-                }
-            }
-        }
-
-        foreach (var (_, files) in musicFolders)
-            files.Sort((x, y) => x.file.Filename.CompareTo(y.file.Filename));
-
-
-        var fileCounts = musicFolders.Select(x =>
-            x.Item2.Count(x => Utils.IsMusicFile(x.file.Filename))
-        ).ToList();
-
-        int min, max;
-        if (track.MinAlbumTrackCount != -1 || track.MaxAlbumTrackCount != -1)
-        {
-            min = track.MinAlbumTrackCount;
-            max = track.MaxAlbumTrackCount;
-        }
-        else
-        {
-            min = minAlbumTrackCount;
-            max = maxAlbumTrackCount;
-        }
-
-        bool countIsGood(int count) => count >= min && (max == -1 || count <= max);
-
-        var result = musicFolders
-            .Where(x => countIsGood(x.Item2.Count(rf => Utils.IsMusicFile(rf.file.Filename))))
-            .Select(ls => ls.Item2.Select(x => {
-                var t = new Track
-                {
-                    Artist = track.Artist,
-                    Album = track.Album,
-                    IsNotAudio = !Utils.IsMusicFile(x.file.Filename),
-                    Downloads = new ConcurrentDictionary<string, (SlResponse, SlFile file)>(
-                        new Dictionary<string, (SlResponse response, SlFile file)> { { x.response.Username + "\\" + x.file.Filename, x } })
-                };
-                return skipExisting ? InferTrack(x.file.Filename, t) : t;
-            })
-            .OrderBy(t => t.IsNotAudio)
-            .ThenBy(t => t.Downloads.First().Value.Item2.Filename)
-            .ToList()).Where(ls => ls.Count > 0).ToList();
-
-        if (result.Count == 0)
-            result.Add(new List<Track>()); 
-
-        return result;
-    }
-
-
-    static async Task<List<Track>> GetUniqueRelatedTracks(Track track)
-    {
-        var results = new ConcurrentDictionary<string, (SearchResponse, Soulseek.File)>();
-        SearchOptions getSearchOptions(int timeout, FileConditions nec, FileConditions prf) =>
-            new SearchOptions(
-                minimumResponseFileCount: 1,
-                minimumPeerUploadSpeed: 1,
-                removeSingleCharacterSearchTerms: removeSingleCharacterSearchTerms,
-                searchTimeout: timeout,
-                responseFilter: (response) =>
-                {
-                    return response.UploadSpeed > 0 && nec.BannedUsersSatisfies(response);
-                },
-                fileFilter: (file) =>
-                {
-                    return Utils.IsMusicFile(file.Filename) && nec.FileSatisfies(file, track, null);
-                    //&& FileConditions.StrictString(file.Filename, track.ArtistName, ignoreCase: true)
-                    //&& FileConditions.StrictString(file.Filename, track.TrackTitle, ignoreCase: true)
-                    //&& FileConditions.StrictString(file.Filename, track.Album, ignoreCase: true);
-                }
-            );
-        void handler(SlResponse r)
-        {
-            if (r.Files.Count > 0)
-            {
-                foreach (var file in r.Files)
-                    results.TryAdd(r.Username + "\\" + file.Filename, (r, file));
-            }
-        }
-        var cts = new CancellationTokenSource();
-
-        await RunSearches(track, results, getSearchOptions, handler, cts.Token);
-
-        string artistName = track.Artist.Trim();
-        string trackName = track.Title.Trim();
-        string albumName = track.Album.Trim();
-
-        var fileResponses = results.Select(x => x.Value);
-
-        var equivalentFiles = EquivalentFiles(track, fileResponses).ToList();
-
-        if (!relax)
-        {
-            equivalentFiles = equivalentFiles
-                .Where(x => FileConditions.StrictString(x.Item1.Title, track.Title, ignoreCase: true)
-                        && (FileConditions.StrictString(x.Item1.Artist, track.Artist, ignoreCase: true, boundarySkipWs: false) 
-                            || FileConditions.StrictString(x.Item1.Title, track.Artist, ignoreCase: true, boundarySkipWs: false)
-                                && x.Item1.Title.ContainsInBrackets(track.Artist, ignoreCase: true)))
-                .ToList();
-        }
-
-        var tracks = equivalentFiles
-            .Select(kvp => {
-                kvp.Item1.Downloads = new ConcurrentDictionary<string, (SearchResponse, Soulseek.File)>(
-                    kvp.Item2.ToDictionary(item => { return item.response.Username + "\\" + item.file.Filename; }, item => item));
-                return kvp.Item1; 
-            }).ToList();
-
-        return tracks;
-    }
-
-
-    static IOrderedEnumerable<(Track, IEnumerable<(SlResponse response, SlFile file)>)> EquivalentFiles(Track track, 
-        IEnumerable<(SlResponse, SlFile)> fileResponses, int minShares=-1)
-    {
-        if (minShares == -1)
-            minShares = minUsersAggregate;
-
-        Track inferTrack((SearchResponse r, Soulseek.File f) x)
-        {
-            Track t = track;
-            t.Length = x.f.Length ?? -1;
-            return InferTrack(x.f.Filename, t);
-        }
-
-        var res = fileResponses
-            .GroupBy(inferTrack, new TrackStringComparer(ignoreCase: true))
-            .Where(group => group.Select(x => x.Item1.Username).Distinct().Count() >= minShares)
-            .SelectMany(group => {
-                var sortedTracks = group.OrderBy(t => t.Item2.Length).Where(x => x.Item2.Length != null).ToList();
-                var groups = new List<(Track, List<(SearchResponse, Soulseek.File)>)>();
-                var noLengthGroup = group.Where(x => x.Item2.Length == null);
-                for (int i = 0; i < sortedTracks.Count;)
-                {
-                    var subGroup = new List<(SearchResponse, Soulseek.File)> { sortedTracks[i] };
-                    int j = i + 1;
-                    while (j < sortedTracks.Count)
-                    {
-                        int l1 = (int)sortedTracks[j].Item2.Length;
-                        int l2 = (int)sortedTracks[i].Item2.Length;
-                        if (necessaryCond.LengthTolerance == -1 || Math.Abs(l1 - l2) <= necessaryCond.LengthTolerance)
-                        {
-                            subGroup.Add(sortedTracks[j]);
-                            j++;
-                        }
-                        else break;
-                    }
-                    Track t = group.Key;
-                    t.Length = (int)sortedTracks[i].Item2.Length;
-                    groups.Add((t, subGroup));
-                    i = j;
-                }
-
-                if (noLengthGroup.Any())
-                {
-                    if (groups.Count > 0 && !preferredCond.AcceptNoLength)
-                        groups.First().Item2.AddRange(noLengthGroup);
-                    else
-                        groups.Add((group.Key, noLengthGroup.ToList()));
-                }
-
-                return groups.Where(subGroup => subGroup.Item2.Select(x => x.Item1.Username).Distinct().Count() >= minShares)
-                    .Select(subGroup => (subGroup.Item1, subGroup.Item2.AsEnumerable()));
-            }).OrderByDescending(x => x.Item2.Count());
-
-        return res;
-    }
-
-
-    static IOrderedEnumerable<(SlResponse response, SlFile file)> OrderedResults(IEnumerable<KeyValuePair<string, (SlResponse, SlFile)>> results, 
-        Track track, bool useInfer=false, bool useLevenshtein=true, bool albumMode=false)
-    {
-        bool useBracketCheck = true;
-        if (albumMode)
-        {
-            useBracketCheck = false;
-            useLevenshtein = false;
-            useInfer = false;
-        }
-
-        Dictionary<string, (Track, int)>? infTracksAndCounts = null;
-        if (useInfer)
-        {
-            var equivalentFiles = EquivalentFiles(track, results.Select(x => x.Value), 1);
-            infTracksAndCounts = equivalentFiles
-                .SelectMany(t => t.Item2, (t, f) => new { t.Item1, f.response.Username, f.file.Filename, Count = t.Item2.Count() })
-                .ToSafeDictionary(x => $"{x.Username}\\{x.Filename}", y => (y.Item1, y.Count));
-        }
-
-        (Track, int) inferredTrack((SearchResponse response, Soulseek.File file) x)
-        {
-            string key = $"{x.response.Username}\\{x.file.Filename}";
-            if (infTracksAndCounts != null && infTracksAndCounts.ContainsKey(key))
-                return infTracksAndCounts[key];
-            return (new Track(), 0);
-        }
-
-        int levenshtein((SearchResponse response, Soulseek.File file) x)
-        {
-            Track t = inferredTrack(x).Item1;
-            string t1 = track.Title.RemoveFt().ReplaceSpecialChars("").Replace(" ", "").Replace("_", "").ToLower();
-            string t2 = t.Title.RemoveFt().ReplaceSpecialChars("").Replace(" ", "").Replace("_", "").ToLower();
-            return Utils.Levenshtein(t1, t2);
-        }
-
-        var random = new Random();
-        return results.Select(kvp => (response: kvp.Value.Item1, file: kvp.Value.Item2))
-                .Where(x => userSuccessCount.GetValueOrDefault(x.response.Username, 0) > ignoreOn)
-                .OrderByDescending(x => userSuccessCount.GetValueOrDefault(x.response.Username, 0) > deprioritizeOn)
-                .ThenByDescending(x => necessaryCond.FileSatisfies(x.file, track, x.response))
-                .ThenByDescending(x => preferredCond.BannedUsersSatisfies(x.response))
-                .ThenByDescending(x => (x.file.Length != null && x.file.Length > 0) || preferredCond.AcceptNoLength)
-                .ThenByDescending(x => !useBracketCheck || BracketCheck(track, inferredTrack(x).Item1)) // deprioritize result if it contains '(' or '[' and the title does not (avoid remixes)
-                .ThenByDescending(x => preferredCond.StrictTitleSatisfies(x.file.Filename, track.Title))
-                .ThenByDescending(x => preferredCond.StrictArtistSatisfies(x.file.Filename, track.Title))
-                .ThenByDescending(x => preferredCond.LengthToleranceSatisfies(x.file, track.Length))
-                .ThenByDescending(x => preferredCond.FormatSatisfies(x.file.Filename))
-                .ThenByDescending(x => preferredCond.StrictAlbumSatisfies(x.file.Filename, track.Album))
-                .ThenByDescending(x => preferredCond.BitrateSatisfies(x.file))
-                .ThenByDescending(x => preferredCond.SampleRateSatisfies(x.file))
-                .ThenByDescending(x => preferredCond.BitDepthSatisfies(x.file))
-                .ThenByDescending(x => preferredCond.FileSatisfies(x.file, track, x.response))
-                .ThenByDescending(x => x.response.HasFreeUploadSlot)
-                .ThenByDescending(x => x.response.UploadSpeed / 1024 / 650)
-                .ThenByDescending(x => albumMode || FileConditions.StrictString(x.file.Filename, track.Title))
-                .ThenByDescending(x => !albumMode || FileConditions.StrictString(GetDirectoryNameSlsk(x.file.Filename), track.Album))
-                .ThenByDescending(x => FileConditions.StrictString(x.file.Filename, track.Artist, boundarySkipWs: false))
-                .ThenByDescending(x => useInfer ? inferredTrack(x).Item2 : 0) // sorts by the number of occurences of this track
-                .ThenByDescending(x => x.response.UploadSpeed / 1024 / 350)
-                .ThenByDescending(x => (x.file.BitRate ?? 0) / 80)
-                .ThenByDescending(x => useLevenshtein ? levenshtein(x) / 5 : 0) // sorts by the distance between the track title and the inferred title of the search result
-                .ThenByDescending(x => random.Next());
-    }
-
-
-    static bool BracketCheck(Track track, Track other)
-    {
-        string t1 = track.Title.RemoveFt().Replace('[', '(');
-        if (t1.Contains('('))
-            return true;
-
-        string t2 = other.Title.RemoveFt().Replace('[', '(');
-        if (!t2.Contains('('))
-            return true;
-
-        return false;
-    }
-
-
-    static async Task RunSearches(Track track, SlDictionary results, Func<int, FileConditions, FileConditions, SearchOptions> getSearchOptions, 
-        Action<SearchResponse> responseHandler, CancellationToken ct, Action? onSearch = null)
-    {
-        bool artist = track.Artist != "";
-        bool title = track.Title != "";
-        bool album = track.Album != "";
-
-        string search = GetSearchString(track);
-        var searchTasks = new List<Task>();
-
-        var defaultSearchOpts = getSearchOptions(searchTimeout, necessaryCond, preferredCond);
-        searchTasks.Add(Search(search, defaultSearchOpts, responseHandler, ct, onSearch));
-
-        if (search.RemoveDiacriticsIfExist(out string noDiacrSearch) && !track.ArtistMaybeWrong)
-            searchTasks.Add(Search(noDiacrSearch, defaultSearchOpts, responseHandler, ct, onSearch));
-
-        await Task.WhenAll(searchTasks);
-
-        if (results.IsEmpty && track.ArtistMaybeWrong && title)
-        {
-            var cond = new FileConditions(necessaryCond);
-            var infTrack = InferTrack(track.Title, new Track());
-            cond.StrictTitle = infTrack.Title == track.Title;
-            cond.StrictArtist = false;
-            var opts = getSearchOptions(Math.Min(searchTimeout, 5000), cond, preferredCond);
-            searchTasks.Add(Search($"{infTrack.Artist} {infTrack.Title}", opts, responseHandler, ct, onSearch));
-        }
-
-        if (desperateSearch)
-        {
-            await Task.WhenAll(searchTasks);
-
-            if (results.IsEmpty && !track.ArtistMaybeWrong)
-            {
-                if (artist && album && title)
-                {
-                    var cond = new FileConditions(necessaryCond)
-                    {
-                        StrictTitle = true,
-                        StrictAlbum = true
-                    };
-                    var opts = getSearchOptions(Math.Min(searchTimeout, 5000), cond, preferredCond);
-                    searchTasks.Add(Search($"{track.Artist} {track.Album}", opts, responseHandler, ct, onSearch));
-                }
-                if (artist && title && track.Length != -1 && necessaryCond.LengthTolerance != -1)
-                {
-                    var cond = new FileConditions(necessaryCond)
-                    {
-                        LengthTolerance = -1,
-                        StrictTitle = true,
-                        StrictArtist = true
-                    };
-                    var opts = getSearchOptions(Math.Min(searchTimeout, 5000), cond, preferredCond);
-                    searchTasks.Add(Search($"{track.Artist} {track.Title}", opts, responseHandler, ct, onSearch));
-                }
-            }
-
-            await Task.WhenAll(searchTasks);
-
-            if (results.IsEmpty)
-            {
-                var track2 = track.ArtistMaybeWrong ? InferTrack(track.Title, new Track()) : track;
-
-                if (track.Album.Length > 3 && album)
-                {
-                    var cond = new FileConditions(necessaryCond)
-                    {
-                        StrictAlbum = true,
-                        StrictTitle = !track.ArtistMaybeWrong,
-                        StrictArtist = !track.ArtistMaybeWrong,
-                        LengthTolerance = -1
-                    };
-                    var opts = getSearchOptions(Math.Min(searchTimeout, 5000), cond, preferredCond);
-                    searchTasks.Add(Search($"{track.Album}", opts, responseHandler, ct, onSearch));
-                }
-                if (track2.Title.Length > 3 && artist)
-                {
-                    var cond = new FileConditions(necessaryCond)
-                    {
-                        StrictTitle = !track.ArtistMaybeWrong,
-                        StrictArtist = !track.ArtistMaybeWrong,
-                        LengthTolerance = -1
-                    };
-                    var opts = getSearchOptions(Math.Min(searchTimeout, 5000), cond, preferredCond);
-                    searchTasks.Add(Search($"{track2.Title}", opts, responseHandler, ct, onSearch));
-                }
-                if (track2.Artist.Length > 3 && title)
-                {
-                    var cond = new FileConditions(necessaryCond)
-                    {
-                        StrictTitle = !track.ArtistMaybeWrong,
-                        StrictArtist = !track.ArtistMaybeWrong,
-                        LengthTolerance = -1
-                    };
-                    var opts = getSearchOptions(Math.Min(searchTimeout, 5000), cond, preferredCond);
-                    searchTasks.Add(Search($"{track2.Artist}", opts, responseHandler, ct, onSearch));
-                }
-            }
-        }
-
-        await Task.WhenAll(searchTasks);
-    }
-
-
-    static async Task Search(string search, SearchOptions opts, Action<SearchResponse> rHandler, CancellationToken ct, Action? onSearch = null)
-    {
-        await searchSemaphore.WaitAsync();
-        try
-        {
-            search = CleanSearchString(search);
-            var q = SearchQuery.FromText(search);
-            var searchTasks = new List<Task>();
-            onSearch?.Invoke();
-            await client.SearchAsync(q, options: opts, cancellationToken: ct, responseHandler: rHandler);
-        }
-        catch (OperationCanceledException) { }
-    }
-
-
-    public static string GetSearchString(Track track)
-    {
-        if (track.Title != "")
-            return (track.Artist + " " + track.Title).Trim();
-        else if (track.Album != "")
-            return (track.Artist + " " + track.Album).Trim();
-        return track.Artist.Trim();
-    }
-
-
-    public static string CleanSearchString(string str)
-    {
-        string old;
-        if (!noRemoveSpecialChars)
-        {
-            old = str;
-            str = str.ReplaceSpecialChars(" ").Trim().RemoveConsecutiveWs();
-            if (str == "") str = old;
-        }
-        foreach (var banned in bannedTerms)
-        {
-            string b1 = banned;
-            string b2 = banned.Replace(" ", "-");
-            string b3 = banned.Replace(" ", "_");
-            string b4 = banned.Replace(" ", "");
-            foreach (var s in new string[] { b1, b2, b3, b4 })
-                str = str.Replace(s, string.Concat("*", s.AsSpan(1)), StringComparison.OrdinalIgnoreCase);
-        }
-
-        return str.Trim();
-    }
-
-
-    public static Track InferTrack(string filename, Track defaultTrack)
-    {
-        Track t = new Track(defaultTrack);
-        filename = GetFileNameWithoutExtSlsk(filename).Replace(" — ", " - ").Replace("_", " ").Trim().RemoveConsecutiveWs();
-
-        var trackNumStart = new Regex(@"^(?:(?:[0-9][-\.])?\d{2,3}[. -]|\b\d\.\s|\b\d\s-\s)(?=.+\S)");
-        //var trackNumMiddle = new Regex(@"\s+-\s+(\d{2,3})(?: -|\.|)\s+|\s+-(\d{2,3})-\s+");
-        var trackNumMiddle = new Regex(@"(?<= - )((\d-)?\d{2,3}|\d{2,3}\.?)\s+");
-        var trackNumMiddleAlt = new Regex(@"\s+-(\d{2,3})-\s+");
-
-        if (trackNumStart.IsMatch(filename))
-        {
-            filename = trackNumStart.Replace(filename, "", 1).Trim();
-            if (filename.StartsWith("- "))
-                filename = filename.Substring(2).Trim();
-        }
-        else
-        {
-            var reg = trackNumMiddle.IsMatch(filename) ? trackNumMiddle : (trackNumMiddleAlt.IsMatch(filename) ? trackNumMiddleAlt : null);
-            if (reg != null && !reg.IsMatch(defaultTrack.ToString(noInfo: true)))
-            {
-                filename = reg.Replace(filename, "<<tracknum>>", 1).Trim();
-                filename = Regex.Replace(filename, @"-\s*<<tracknum>>\s*-", "-");
-                filename = filename.Replace("<<tracknum>>", "");
-            }
-        }
-
-        string aname = t.Artist.Trim();
-        string tname = t.Title.Trim();
-        string alname = t.Album.Trim();
-        string fname = filename;
-
-        fname = fname.Replace("—", "-").Replace("_", " ").Replace('[', '(').Replace(']', ')').ReplaceInvalidChars("", true).RemoveConsecutiveWs().Trim();
-        tname = tname.Replace("—", "-").Replace("_", " ").Replace('[', '(').Replace(']', ')').ReplaceInvalidChars("", true).RemoveFt().RemoveConsecutiveWs().Trim();
-        aname = aname.Replace("—", "-").Replace("_", " ").Replace('[', '(').Replace(']', ')').ReplaceInvalidChars("", true).RemoveFt().RemoveConsecutiveWs().Trim();
-        alname = alname.Replace("—", "-").Replace("_", " ").Replace('[', '(').Replace(']', ')').ReplaceInvalidChars("", true).RemoveFt().RemoveConsecutiveWs().Trim();
-
-        bool maybeRemix = aname != "" && Regex.IsMatch(fname, @$"\({Regex.Escape(aname)} .+\)", RegexOptions.IgnoreCase);
-        string[] parts = fname.Split(new string[] { " - " }, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
-        string[] realParts = filename.Split(new string[] { " - " }, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
-
-        if (parts.Length != realParts.Length)
-            realParts = parts;
-
-        if (parts.Length == 1)
-        {
-            if (maybeRemix)
-                t.ArtistMaybeWrong = true;
-            t.Title = parts[0];
-        }
-        else if (parts.Length == 2)
-        {
-            t.Artist = realParts[0];
-            t.Title = realParts[1];
-
-            if (!parts[0].ContainsIgnoreCase(aname) || !parts[1].ContainsIgnoreCase(tname))
-            {
-                t.ArtistMaybeWrong = true;
-            }
-        }
-        else if (parts.Length == 3)
-        {
-            bool hasTitle = tname != "" && parts[2].ContainsIgnoreCase(tname);
-            if (hasTitle)
-                t.Title = realParts[2];
-
-            int artistPos = -1;
-            if (aname != "")
-            {
-                if (parts[0].ContainsIgnoreCase(aname))
-                    artistPos = 0;
-                else if (parts[1].ContainsIgnoreCase(aname))
-                    artistPos = 1;
-                else
-                    t.ArtistMaybeWrong = true;
-            }
-            int albumPos = -1;
-            if (alname != "")
-            {
-                if (parts[0].ContainsIgnoreCase(alname))
-                    albumPos = 0;
-                else if (parts[1].ContainsIgnoreCase(alname))
-                    albumPos = 1;
-            }
-            if (artistPos >= 0 && artistPos == albumPos)
-            {
-                artistPos = 0;
-                albumPos = 1;
-            }
-            if (artistPos == -1 && maybeRemix)
-            {
-                t.ArtistMaybeWrong = true;
-                artistPos = 0;
-                albumPos = 1;
-            }
-            if (artistPos == -1 && albumPos == -1)
-            {
-                t.ArtistMaybeWrong = true;
-                t.Artist = realParts[0] + " - " + realParts[1];
-            }
-            else if (artistPos >= 0)
-            {
-                t.Artist = parts[artistPos];
-            }
-
-            t.Title = parts[2];
-        }
-        else
-        {
-            int artistPos = -1, titlePos = -1;
-
-            if (aname != "")
-            {
-                var s = parts.Select((p, i) => (p, i)).Where(x => x.p.ContainsIgnoreCase(aname));
-                if (s.Any())
-                {
-                    artistPos = s.MinBy(x => Math.Abs(x.p.Length - aname.Length)).i;
-                    if (artistPos != -1)
-                        t.Artist = parts[artistPos];
-                }
-            }
-            if (tname != "")
-            {
-                var ss = parts.Select((p, i) => (p, i)).Where(x => x.i != artistPos && x.p.ContainsIgnoreCase(tname));
-                if (ss.Any())
-                {
-                    titlePos = ss.MinBy(x => Math.Abs(x.p.Length - tname.Length)).i;
-                    if (titlePos != -1)
-                        t.Title = parts[titlePos];
-                }
-            }
-        }
-
-        if (t.Title == "")
-        {
-            t.Title = fname;
-            t.ArtistMaybeWrong = true;
-        }
-        else if (t.Artist != "" && !t.Title.ContainsIgnoreCase(defaultTrack.Title) && !t.Artist.ContainsIgnoreCase(defaultTrack.Artist))
-        {
-            string[] x = { t.Artist, t.Album, t.Title };
-
-            var perm = (0, 1, 2);
-            (int, int, int)[] permutations = { (0, 2, 1), (1, 0, 2), (1, 2, 0), (2, 0, 1), (2, 1, 0) };
-
-            foreach (var p in permutations)
-            {
-                if (x[p.Item1].ContainsIgnoreCase(defaultTrack.Artist) && x[p.Item3].ContainsIgnoreCase(defaultTrack.Title))
-                {
-                    perm = p;
-                    break;
-                }
-            }
-
-            t.Artist = x[perm.Item1];
-            t.Album = x[perm.Item2];
-            t.Title = x[perm.Item3];
-        }
-
-        t.Title = t.Title.RemoveFt();
-        t.Artist = t.Artist.RemoveFt();
-
-        return t;
-    }
-
-
-    static async Task DownloadFile(SearchResponse response, Soulseek.File file, string filePath, Track track, ProgressBar progress, CancellationTokenSource? searchCts=null)
-    {
-        if (debugDisableDownload)
-            throw new Exception();
-
-        await WaitForLogin();
-        Directory.CreateDirectory(Path.GetDirectoryName(filePath));
-        string origPath = filePath;
-        filePath += ".incomplete";
-
-        var transferOptions = new TransferOptions(
-            stateChanged: (state) =>
-            {
-                if (downloads.TryGetValue(file.Filename, out var x))
-                    x.transfer = state.Transfer;
-            },
-            progressUpdated: (progress) =>
-            {
-                if (downloads.TryGetValue(file.Filename, out var x))
-                    x.bytesTransferred = progress.PreviousBytesTransferred;
-            }
-        );
-
-        try
-        {
-            using var cts = new CancellationTokenSource();
-            using var outputStream = new FileStream(filePath, FileMode.Create);
-            downloads.TryAdd(file.Filename, new DownloadWrapper(origPath, response, file, track, cts, progress));
-            await client.DownloadAsync(response.Username, file.Filename, () => Task.FromResult((Stream)outputStream), file.Size, options: transferOptions, cancellationToken: cts.Token);
-        }
-        catch
-        {
-            if (File.Exists(filePath))
-                try { File.Delete(filePath); } catch { }
-            downloads.TryRemove(file.Filename, out var d);
-            if (d != null)
-                lock (d) { d.UpdateText(); }
-            throw;
-        }
-
-        try { searchCts?.Cancel(); }
-        catch { }
-
-        try { Utils.Move(filePath, origPath); }
-        catch (IOException) { WriteLine($"Failed to rename .incomplete file", ConsoleColor.DarkYellow, true); }
-
-        downloads.TryRemove(file.Filename, out var x);
-        if (x != null)
-        {
-            lock (x)
-            {
-                x.success = true;
-                x.UpdateText();
-            }
-        }
-    }
-
-
     static async Task Update()
     {
         while (true)
@@ -3010,7 +955,7 @@ static class Program
             {
                 try
                 {
-                    if (client.State.HasFlag(SoulseekClientStates.LoggedIn))
+                    if (IsConnectedAndLoggedIn())
                     {
                         foreach (var (key, val) in searches)
                         {
@@ -3024,7 +969,7 @@ static class Program
                             {
                                 lock (val)
                                 {
-                                    if ((DateTime.Now - val.UpdateLastChangeTime()).TotalMilliseconds > downloadMaxStaleTime)
+                                    if ((DateTime.Now - val.UpdateLastChangeTime()).TotalMilliseconds > Config.maxStaleTime)
                                     {
                                         val.stalled = true;
                                         val.UpdateText();
@@ -3044,14 +989,25 @@ static class Program
                             }
                         }
                     }
-                    else if (!client.State.HasFlag(SoulseekClientStates.LoggedIn | SoulseekClientStates.LoggingIn | SoulseekClientStates.Connecting))
+                    else
                     {
-                        WriteLine($"\nDisconnected, logging in\n", ConsoleColor.DarkYellow, true);
-                        try { await Login(useRandomLogin); }
-                        catch (Exception ex)
+                        if (!client.State.HasFlag(SoulseekClientStates.LoggedIn | SoulseekClientStates.LoggingIn | SoulseekClientStates.Connecting))
                         {
-                            string banMsg = useRandomLogin ? "" : " (possibly a 30-minute ban caused by frequent searches)";
-                            WriteLine($"{ex.Message}{banMsg}", ConsoleColor.DarkYellow, true);
+                            WriteLine($"\nDisconnected, logging in\n", ConsoleColor.DarkYellow, true);
+                            try { await Login(Config.useRandomLogin); }
+                            catch (Exception ex)
+                            {
+                                string banMsg = Config.useRandomLogin ? "" : " (possibly a 30-minute ban caused by frequent searches)";
+                                WriteLine($"{ex.Message}{banMsg}", ConsoleColor.DarkYellow, true);
+                            }
+                        }
+
+                        foreach (var (key, val) in downloads)
+                        {
+                            if (val != null)
+                                lock (val) { val.UpdateLastChangeTime(updateAllFromThisUser: false, forceChanged: true); }
+                            else
+                                downloads.TryRemove(key, out _);
                         }
                     }
                 }
@@ -3061,20 +1017,20 @@ static class Program
                 }
             }
 
-            await Task.Delay(updateDelay);
+            await Task.Delay(Config.updateDelay);
         }
     }
 
 
     static void OnComplete(string onComplete, Track track)
     {
-        if (onComplete == "")
+        if (onComplete.Length == 0)
             return;
         else if (onComplete.Length > 2 && onComplete[0].IsDigit() && onComplete[1] == ':')
         {
-            if ((int)track.TrackState != int.Parse(onComplete[0].ToString()))
+            if ((int)track.State != int.Parse(onComplete[0].ToString()))
                 return;
-            onComplete = onComplete.Substring(2);
+            onComplete = onComplete[2..];
         }
 
         Process process = new Process();
@@ -3088,9 +1044,10 @@ static class Program
                            .Replace("{artist-maybe-wrong}", track.ArtistMaybeWrong.ToString())
                            .Replace("{is-album}", track.IsAlbum.ToString())
                            .Replace("{is-not-audio}", track.IsNotAudio.ToString())
-                           .Replace("{failure-reason}", track.FailureReason)
+                           .Replace("{failure-reason}", track.FailureReason.ToString())
                            .Replace("{path}", track.DownloadPath)
-                           .Replace("{state}", track.TrackState.ToString())
+                           .Replace("{state}", track.State.ToString())
+                           .Replace("{extractor}", Config.inputType.ToString())
                            .Trim();
 
         if (onComplete[0] == '"')
@@ -3098,7 +1055,7 @@ static class Program
             int e = onComplete.IndexOf('"', 1);
             if (e > 1)
             {
-                startInfo.FileName = onComplete.Substring(1, e - 1);
+                startInfo.FileName = onComplete[1..e];
                 startInfo.Arguments = onComplete.Substring(e + 1, onComplete.Length - e - 1);
             }
             else
@@ -3118,518 +1075,15 @@ static class Program
         startInfo.UseShellExecute = false;
         process.StartInfo = startInfo;
 
+        WriteLine($"on-complete: FileName={startInfo.FileName}, Arguments={startInfo.Arguments}", debugOnly: true);
+
         process.Start();
+        process.BeginOutputReadLine();
+        process.BeginErrorReadLine();
+        process.WaitForExit();
     }
 
 
-    class DownloadWrapper
-    {
-        public string savePath;
-        public string displayText = "";
-        public int downloadRotatingBarState = 0;
-        public Soulseek.File file;
-        public Transfer? transfer;
-        public SearchResponse response;
-        public ProgressBar progress;
-        public Track track;
-        public long bytesTransferred = 0;
-        public bool stalled = false;
-        public bool queued = false;
-        public bool success = false;
-        public CancellationTokenSource cts;
-        public DateTime startTime = DateTime.Now;
-        public DateTime lastChangeTime = DateTime.Now;
-
-        private TransferStates? prevTransferState = null;
-        private long prevBytesTransferred = 0;
-        private bool updatedTextDownload = false;
-        private bool updatedTextSuccess = false;
-
-        public DownloadWrapper(string savePath, SearchResponse response, Soulseek.File file, Track track, CancellationTokenSource cts, ProgressBar progress)
-        {
-            this.savePath = savePath;
-            this.response = response;
-            this.file = file;
-            this.cts = cts;
-            this.track = track;
-            this.progress = progress;
-            this.displayText = DisplayString(track, file, response);
-
-            RefreshOrPrint(progress, 0, "Initialize: " + displayText, true);
-            RefreshOrPrint(progress, 0, displayText, false);
-        }
-
-        public void UpdateText()
-        {
-            char[] bars = { '/', '|', '\\', '―' };
-            downloadRotatingBarState++;
-            downloadRotatingBarState %= bars.Length;
-            string bar = success ? "" : bars[downloadRotatingBarState] + " ";
-            float? percentage = bytesTransferred / (float)file.Size;
-            queued = transfer?.State.ToString().Contains("Queued") ?? false;
-            string state = "NullState";
-            bool downloading = false;
-
-            if (stalled)
-            {
-                state = "Stalled";
-                bar = "";
-            }
-            else if (transfer != null)
-            {
-                state = transfer.State.ToString();
-
-                if (queued)
-                    state = "Queued";
-                else if (state.Contains("Completed, "))
-                    state = state.Replace("Completed, ", "");
-                else if (state.Contains("Initializing"))
-                    state = "Initialize";
-            }
-
-            if (state == "Succeeded")
-                success = true;
-            if (state == "InProgress")
-                downloading = true;
-
-            string txt = $"{bar}{state}:".PadRight(14, ' ');
-            bool needSimplePrintUpdate = (downloading && !updatedTextDownload) || (success && !updatedTextSuccess);
-            updatedTextDownload |= downloading;
-            updatedTextSuccess |= success;
-
-            Console.ResetColor();
-            RefreshOrPrint(progress, (int)((percentage ?? 0) * 100), $"{txt} {displayText}", needSimplePrintUpdate, needSimplePrintUpdate);
-
-        }
-
-        public DateTime UpdateLastChangeTime(bool propagate=true, bool forceChanged=false)
-        {
-            bool changed = prevTransferState != transfer?.State || prevBytesTransferred != bytesTransferred;
-            if (changed || forceChanged)
-            {
-                lastChangeTime= DateTime.Now;
-                stalled = false;
-                if (propagate)
-                {
-                    foreach (var (_, dl) in downloads)
-                    {
-                        if (dl != this && dl.response.Username == response.Username) 
-                            dl.UpdateLastChangeTime(propagate: false, forceChanged: true);
-                    }
-                }
-            }
-            prevTransferState = transfer?.State;
-            prevBytesTransferred = bytesTransferred;
-            return lastChangeTime;
-        }
-    }
-
-
-    class SearchInfo
-    {
-        public ConcurrentDictionary<string, (SearchResponse, Soulseek.File)> results;
-        public ProgressBar progress;
-
-        public SearchInfo(ConcurrentDictionary<string, (SearchResponse, Soulseek.File)> results, ProgressBar progress)
-        {
-            this.results = results;
-            this.progress = progress;
-        }
-    }
-
-
-    class FileConditions
-    {
-        public int LengthTolerance = -1;
-        public int MinBitrate = -1;
-        public int MaxBitrate = -1;
-        public int MinSampleRate = -1;
-        public int MaxSampleRate = -1;
-        public int MinBitDepth = -1;
-        public int MaxBitDepth = -1;
-        public bool StrictTitle = false;
-        public bool StrictArtist = false;
-        public bool StrictAlbum = false;
-        public string[] DangerWords = Array.Empty<string>();
-        public string[] Formats = Array.Empty<string>();
-        public string[] BannedUsers = Array.Empty<string>();
-        public string StrictStringRegexRemove = "";
-        public bool StrictStringDiacrRemove = true;
-        public bool AcceptNoLength = true;
-        public bool AcceptMissingProps = true;
-
-        public FileConditions() { }
-
-        public FileConditions(FileConditions other)
-        {
-            LengthTolerance = other.LengthTolerance;
-            MinBitrate = other.MinBitrate;
-            MaxBitrate = other.MaxBitrate;
-            MinSampleRate = other.MinSampleRate;
-            MaxSampleRate = other.MaxSampleRate;
-            AcceptNoLength = other.AcceptNoLength;
-            StrictArtist = other.StrictArtist;
-            StrictTitle = other.StrictTitle;
-            MinBitDepth = other.MinBitDepth;
-            MaxBitDepth = other.MaxBitDepth;
-            Formats = other.Formats.ToArray();
-            DangerWords = other.DangerWords.ToArray();
-            BannedUsers = other.BannedUsers.ToArray();
-        }
-
-        public void UnsetClientSpecificFields()
-        {
-            MinBitrate = -1;
-            MaxBitrate = -1;
-            MinSampleRate = -1;
-            MaxSampleRate = -1;
-            MinBitDepth = -1;
-            MaxBitDepth = -1;
-        }
-
-        public bool FileSatisfies(Soulseek.File file, Track track, SearchResponse? response)
-        {
-            return DangerWordSatisfies(file.Filename, track.Title, track.Artist) && FormatSatisfies(file.Filename) 
-                && LengthToleranceSatisfies(file, track.Length) && BitrateSatisfies(file) && SampleRateSatisfies(file) 
-                && StrictTitleSatisfies(file.Filename, track.Title) && StrictArtistSatisfies(file.Filename, track.Artist) 
-                && StrictAlbumSatisfies(file.Filename, track.Album) && BannedUsersSatisfies(response) && BitDepthSatisfies(file);
-        }
-
-        public bool FileSatisfies(TagLib.File file, Track track)
-        {
-            return DangerWordSatisfies(file.Name, track.Title, track.Artist) && FormatSatisfies(file.Name) 
-                && LengthToleranceSatisfies(file, track.Length) && BitrateSatisfies(file) && SampleRateSatisfies(file) 
-                && StrictTitleSatisfies(file.Name, track.Title) && StrictArtistSatisfies(file.Name, track.Artist)
-                && StrictAlbumSatisfies(file.Name, track.Album) && BitDepthSatisfies(file);
-        }
-
-        public bool DangerWordSatisfies(string fname, string tname, string aname)
-        {
-            if (tname == "")
-                return true;
-
-            fname = GetFileNameWithoutExtSlsk(fname).Replace(" — ", " - ");
-            tname = tname.Replace(" — ", " - ");
-
-            foreach (var word in DangerWords)
-            {
-                if (fname.ContainsIgnoreCase(word) ^ tname.ContainsIgnoreCase(word))
-                {
-                    if (!(fname.Contains(" - ") && fname.ContainsIgnoreCase(word) && aname.ContainsIgnoreCase(word)))
-                    {
-                        if (word == "mix")
-                            return fname.ContainsIgnoreCase("original mix") || tname.ContainsIgnoreCase("original mix");
-                        else
-                            return false;
-                    }
-                }
-            }
-
-            return true;
-        }
-
-        public bool StrictTitleSatisfies(string fname, string tname, bool noPath = true)
-        {
-            if (!StrictTitle || tname == "")
-                return true;
-
-            fname = noPath ? GetFileNameWithoutExtSlsk(fname) : fname;
-            return StrictString(fname, tname, StrictStringRegexRemove, StrictStringDiacrRemove, ignoreCase: true);
-        }
-
-        public bool StrictArtistSatisfies(string fname, string aname)
-        {
-            if (!StrictArtist || aname == "")
-                return true;
-
-            return StrictString(fname, aname, StrictStringRegexRemove, StrictStringDiacrRemove, ignoreCase: true, boundarySkipWs: false);
-        }
-
-        public bool StrictAlbumSatisfies(string fname, string alname)
-        {
-            if (!StrictAlbum || alname == "")
-                return true;
-
-            return StrictString(GetDirectoryNameSlsk(fname), alname, StrictStringRegexRemove, StrictStringDiacrRemove, ignoreCase: true);
-        }
-
-        public static bool StrictString(string fname, string tname, string regexRemove = "", bool diacrRemove = true, bool ignoreCase = true, bool boundarySkipWs = true)
-        {
-            if (string.IsNullOrEmpty(tname))
-                return true;
-
-            fname = fname.Replace("_", " ").ReplaceInvalidChars(" ", true, false);
-            fname = regexRemove != "" ? Regex.Replace(fname, regexRemove, "") : fname;
-            fname = diacrRemove ? fname.RemoveDiacritics() : fname;
-            fname = fname.Trim().RemoveConsecutiveWs();
-            tname = tname.Replace("_", " ").ReplaceInvalidChars(" ", true, true);
-            tname = regexRemove != "" ? Regex.Replace(tname, regexRemove, "") : tname;
-            tname = diacrRemove ? tname.RemoveDiacritics() : tname;
-            tname = tname.Trim().RemoveConsecutiveWs();
-
-            if (boundarySkipWs)
-                return fname.ContainsWithBoundaryIgnoreWs(tname, ignoreCase, acceptLeftDigit: true);
-            else
-                return fname.ContainsWithBoundary(tname, ignoreCase);
-        }
-
-        public bool FormatSatisfies(string fname)
-        {
-            string ext = Path.GetExtension(fname).Trim('.').ToLower();
-            return Formats.Length == 0 || (ext != "" && Formats.Any(f => f == ext));
-        }
-
-        public bool LengthToleranceSatisfies(Soulseek.File file, int wantedLength)
-        {
-            return LengthToleranceSatisfies(file.Length, wantedLength);
-        }
-
-        public bool LengthToleranceSatisfies(TagLib.File file, int wantedLength)
-        {
-            return LengthToleranceSatisfies((int)file.Properties.Duration.TotalSeconds, wantedLength);
-        }
-
-        public bool LengthToleranceSatisfies(int? length, int wantedLength)
-        {
-            if (LengthTolerance < 0 || wantedLength < 0)
-                return true;
-            if (length == null || length < 0)
-                return AcceptNoLength && AcceptMissingProps;
-            return Math.Abs((int)length - wantedLength) <= LengthTolerance;
-        }
-
-        public bool BitrateSatisfies(Soulseek.File file)
-        {
-            return BitrateSatisfies(file.BitRate);
-        }
-
-        public bool BitrateSatisfies(TagLib.File file)
-        {
-            return BitrateSatisfies(file.Properties.AudioBitrate);
-        }
-
-        public bool BitrateSatisfies(int? bitrate)
-        {
-            return BoundCheck(bitrate, MinBitrate, MaxBitrate);
-        }
-
-        public bool SampleRateSatisfies(Soulseek.File file)
-        {
-            return SampleRateSatisfies(file.SampleRate);
-        }
-
-        public bool SampleRateSatisfies(TagLib.File file)
-        {
-            return SampleRateSatisfies(file.Properties.AudioSampleRate);
-        }
-
-        public bool SampleRateSatisfies(int? sampleRate)
-        {
-            return BoundCheck(sampleRate, MinSampleRate, MaxSampleRate);
-        }
-
-        public bool BitDepthSatisfies(Soulseek.File file)
-        {
-            return BitDepthSatisfies(file.BitDepth);
-        }
-
-        public bool BitDepthSatisfies(TagLib.File file)
-        {
-            return BitDepthSatisfies(file.Properties.BitsPerSample);
-        }
-
-        public bool BitDepthSatisfies(int? bitdepth)
-        {
-            return BoundCheck(bitdepth, MinBitDepth, MaxBitDepth);
-        }
-
-        public bool BoundCheck(int? num, int min, int max)
-        {
-            if (max < 0 && min < 0)
-                return true;
-            if (num == null || num < 0)
-                return AcceptMissingProps;
-            if (num < min || max != -1 && num > max)
-                return false;
-            return true;
-        }
-
-        public bool BannedUsersSatisfies(SearchResponse? response)
-        {
-            return response == null || !BannedUsers.Any(x => x == response.Username);
-        }
-
-        public string GetNotSatisfiedName(Soulseek.File file, Track track, SearchResponse? response)
-        {
-            if (!DangerWordSatisfies(file.Filename, track.Title, track.Artist))
-                return "DangerWord fails";
-            if (!FormatSatisfies(file.Filename))
-                return "Format fails";
-            if (!LengthToleranceSatisfies(file, track.Length))
-                return "Length fails";
-            if (!BitrateSatisfies(file))
-                return "Bitrate fails";
-            if (!SampleRateSatisfies(file))
-                return "SampleRate fails";
-            if (!StrictTitleSatisfies(file.Filename, track.Title))
-                return "StrictTitle fails";
-            if (!StrictArtistSatisfies(file.Filename, track.Artist))
-                return "StrictArtist fails";
-            if (!BitDepthSatisfies(file))
-                return "BitDepth fails";
-            if (!BannedUsersSatisfies(response))
-                return "BannedUsers fails";
-            return "Satisfied";                               
-        }
-
-        public string GetNotSatisfiedName(TagLib.File file, Track track)
-        {
-            if (!DangerWordSatisfies(file.Name, track.Title, track.Artist))
-                return "DangerWord fails";
-            if (!FormatSatisfies(file.Name))
-                return "Format fails";
-            if (!LengthToleranceSatisfies(file, track.Length))
-                return "Length fails";
-            if (!BitrateSatisfies(file))
-                return "Bitrate fails";
-            if (!SampleRateSatisfies(file))
-                return "SampleRate fails";
-            if (!StrictTitleSatisfies(file.Name, track.Title))
-                return "StrictTitle fails";
-            if (!StrictArtistSatisfies(file.Name, track.Artist))
-                return "StrictArtist fails";
-            if (!BitDepthSatisfies(file))
-                return "BitDepth fails";
-            return "Satisfied";
-        }
-    }
-
-
-    static async Task<List<Track>> ParseCsvIntoTrackInfo(string path, string artistCol = "", string trackCol = "",
-        string lengthCol = "", string albumCol = "", string descCol = "", string ytIdCol = "", string trackCountCol = "", string timeUnit = "s", bool ytParse = false)
-    {
-        var tracks = new List<Track>();
-        using var sr = new StreamReader(path, System.Text.Encoding.UTF8);
-        var parser = new SmallestCSV.SmallestCSVParser(sr);
-
-        int index = 0;
-        var header = parser.ReadNextRow();
-        while (header == null || header.Count == 0 || !header.Any(t => t.Trim() != ""))
-        {
-            index++;
-            header = parser.ReadNextRow();
-        }
-
-        string[] cols = { artistCol, albumCol, trackCol, lengthCol, descCol, ytIdCol, trackCountCol };
-        string[][] aliases = {
-            new[] { "artist", "artist name", "artists", "artist names" },
-            new[] { "album", "album name", "album title" },
-            new[] { "title", "song", "track title", "track name", "song name", "track" },
-            new[] { "length", "duration", "track length", "track duration", "song length", "song duration" },
-            new[] { "description", "youtube description" },
-            new[] { "url", "id", "youtube id" },
-            new[] { "track count", "album track count" }
-        };
-
-        string usingColumns = "";
-        for (int i = 0; i < cols.Length; i++)
-        {
-            if (string.IsNullOrEmpty(cols[i]))
-            {
-                string? res = header.FirstOrDefault(h => Regex.Replace(h, @"\(.*?\)", "").Trim().EqualsAny(aliases[i], StringComparison.OrdinalIgnoreCase));
-                if (!string.IsNullOrEmpty(res))
-                {
-                    cols[i] = res;
-                    usingColumns += $"{aliases[i][0]}:\"{res}\", ";
-                }
-            }
-            else
-            {
-                if (header.IndexOf(cols[i]) == -1)
-                    throw new Exception($"Column \"{cols[i]}\" not found in CSV file");
-                usingColumns += $"{aliases[i][0]}:\"{cols[i]}\", ";
-            }
-        }
-
-        int foundCount = cols.Count(col => col != "");
-        if (!string.IsNullOrEmpty(usingColumns))
-            Console.WriteLine($"Using columns: {usingColumns.TrimEnd(' ', ',')}.");
-        else if (foundCount == 0)
-            throw new Exception("No columns specified and couldn't determine automatically");
-
-        int[] indices = cols.Select(col => col == "" ? -1 : header.IndexOf(col)).ToArray();
-        int artistIndex, albumIndex, trackIndex, lengthIndex, descIndex, ytIdIndex, trackCountIndex;
-        (artistIndex, albumIndex, trackIndex, lengthIndex, descIndex, ytIdIndex, trackCountIndex) = (indices[0], indices[1], indices[2], indices[3], indices[4], indices[5], indices[6]);
-
-        while (true)
-        {
-            index++;
-            var values = parser.ReadNextRow();
-            if (values == null)
-                break;
-            if (!values.Any(t => t.Trim() != ""))
-                continue;
-            while (values.Count < foundCount)
-                values.Add("");
-
-            if (csvColumnCount == -1)
-                csvColumnCount = values.Count;
-
-            var desc = "";
-            var track = new Track() { CsvRow = index };
-
-            if (artistIndex >= 0) track.Artist = values[artistIndex];
-            if (trackIndex >= 0) track.Title = values[trackIndex];
-            if (albumIndex >= 0) track.Album = values[albumIndex];
-            if (descIndex >= 0) desc = values[descIndex];
-            if (ytIdIndex >= 0) track.URI = values[ytIdIndex];
-            if (trackCountIndex >= 0)
-            {
-                string a = values[trackCountIndex].Trim();
-                if (a == "-1")
-                {
-                    track.MinAlbumTrackCount = -1;
-                    track.MaxAlbumTrackCount = -1;
-                }
-                else if (a.Last() == '-' && int.TryParse(a.AsSpan(0, a.Length - 1), out int n))
-                {
-                    track.MaxAlbumTrackCount = n;
-                }
-                else if (a.Last() == '+' && int.TryParse(a.AsSpan(0, a.Length - 1), out n))
-                {
-                    track.MinAlbumTrackCount = n;
-                }
-                else if (int.TryParse(a, out n))
-                {
-                    track.MinAlbumTrackCount = n;
-                    track.MaxAlbumTrackCount = n;
-                }
-            }
-            if (lengthIndex >= 0)
-            {
-                try
-                {
-                    track.Length = (int)ParseTrackLength(values[lengthIndex], timeUnit);
-                }
-                catch
-                {
-                    WriteLine($"Couldn't parse track length \"{values[lengthIndex]}\" with format \"{timeUnit}\" for \"{track}\"", ConsoleColor.DarkYellow);
-                }
-            }
-
-            if (ytParse)
-                track = await YouTube.ParseTrackInfo(track.Title, track.Artist, track.URI, track.Length, desc);
-
-            if (track.Title != "" || track.Artist != "" || track.Album != "")
-                tracks.Add(track);
-        }
-
-        if (ytParse)
-            YouTube.StopService();
-
-        return tracks;
-    }
-
     static string GetSavePath(string sourceFname)
     {
         return $"{GetSavePathNoExt(sourceFname)}{Path.GetExtension(sourceFname)}";
@@ -3637,79 +1091,53 @@ static class Program
 
     static string GetSavePathNoExt(string sourceFname)
     {
-        string outTo = outputFolder;
-        if (albumCommonPath != "")
+        string outTo = Config.outputFolder;
+        if (!string.IsNullOrEmpty(soulseekFolderPathPrefix))
         {
-            string add = sourceFname.Replace(albumCommonPath, "").Replace(GetFileNameSlsk(sourceFname),"").Trim('\\').Trim();
-            if (add!="") outTo = Path.Join(outputFolder, add.Replace('\\', Path.DirectorySeparatorChar));
+            string add = sourceFname.Replace(soulseekFolderPathPrefix, "").Replace(Utils.GetFileNameSlsk(sourceFname), "").Trim('\\').Trim();
+            if (add.Length > 0) outTo = Path.Join(Config.outputFolder, add.Replace('\\', Path.DirectorySeparatorChar));
         }
         return Path.Combine(outTo, $"{GetSaveName(sourceFname)}");
     }
 
     static string GetSaveName(string sourceFname)
     {
-        string name = GetFileNameWithoutExtSlsk(sourceFname);
-        return name.ReplaceInvalidChars(invalidReplaceStr);
-    }
-
-    static string GetAsPathSlsk(string fname)
-    {
-        return fname.Replace('\\', Path.DirectorySeparatorChar);
-    }
-
-    public static string GetFileNameSlsk(string fname)
-    {
-        fname = fname.Replace('\\', Path.DirectorySeparatorChar);
-        return Path.GetFileName(fname);
-    }
-
-    static string GetFileNameWithoutExtSlsk(string fname)
-    {
-        fname = fname.Replace('\\', Path.DirectorySeparatorChar);
-        return Path.GetFileNameWithoutExtension(fname);
-    }
-
-    static string GetExtensionSlsk(string fname)
-    {
-        fname = fname.Replace('\\', Path.DirectorySeparatorChar);
-        return Path.GetExtension(fname).TrimStart('.');
-    }
-
-    static string GetDirectoryNameSlsk(string fname)
-    {
-        fname = fname.Replace('\\', Path.DirectorySeparatorChar);
-        return Path.GetDirectoryName(fname);
+        string name = Utils.GetFileNameWithoutExtSlsk(sourceFname);
+        return name.ReplaceInvalidChars(Config.invalidReplaceStr);
     }
 
     static void ApplyNamingFormatsNonAudio(List<List<Track>> list)
     {
-        if (!nameFormat.Replace("\\", "/").Contains('/'))
+        if (!Config.nameFormat.Replace("\\", "/").Contains('/'))
             return;
 
-        var downloadedTracks = list.SelectMany(x => x)
-            .Where(x => x.DownloadPath != "" && !x.IsNotAudio)
+        var downloadPaths = list.SelectMany(x => x)
+            .Where(x => x.DownloadPath.Length > 0 && !x.IsNotAudio)
             .Select(x => x.DownloadPath).Distinct().ToList();
 
-        if (downloadedTracks.Count == 0)
+        if (downloadPaths.Count == 0)
             return;
 
+        for (int i = 0; i < downloadPaths.Count; i++)
+            downloadPaths[i] = Path.GetFullPath(downloadPaths[i]);
+
         for (int i = 0; i < list.Count; i++)
         {
             for (int j = 0; j < list[i].Count; j++)
             {
                 var track = list[i][j];
-                if (!track.IsNotAudio || track.TrackState != Track.State.Downloaded)
+                if (!track.IsNotAudio || track.State != TrackState.Downloaded)
                     continue;
                 string filepath = track.DownloadPath;
-                string add = Path.GetRelativePath(outputFolder, Path.GetDirectoryName(filepath));
-                string newFilePath = Path.Join(Utils.GreatestCommonPath(downloadedTracks), add, Path.GetFileName(filepath));
+                string add = Path.GetRelativePath(Config.outputFolder, Path.GetDirectoryName(filepath));
+                string newFilePath = Path.Join(Utils.GreatestCommonPath(downloadPaths, Path.DirectorySeparatorChar), add, Path.GetFileName(filepath));
                 if (filepath != newFilePath)
                 {
                     Directory.CreateDirectory(Path.GetDirectoryName(newFilePath));
                     Utils.Move(filepath, newFilePath);
-                    if (add != "" && add != "." && Utils.GetRecursiveFileCount(Path.Join(outputFolder, add)) == 0)
-                        Directory.Delete(Path.Join(outputFolder, add), true);
-                    list[i][j] = new Track(track) { DownloadPath = newFilePath };
+                    if (add.Length > 0 && add != "." && Utils.GetRecursiveFileCount(Path.Join(Config.outputFolder, add)) == 0)
+                        Directory.Delete(Path.Join(Config.outputFolder, add), true);
+                    list[i][j].DownloadPath = newFilePath;
                 }
             }
         }
@@ -3717,17 +1145,17 @@ static class Program
 
     static string ApplyNamingFormat(string filepath, Track track)
     {
-        if (nameFormat == "" || !Utils.IsMusicFile(filepath))
+        if (Config.nameFormat.Length == 0 || !Utils.IsMusicFile(filepath))
             return filepath;
 
         string dir = Path.GetDirectoryName(filepath) ?? "";
-        string add = dir != "" ? Path.GetRelativePath(outputFolder, dir) : "";
-        string newFilePath = NamingFormat(filepath, nameFormat, track);
+        string add = dir.Length > 0 ? Path.GetRelativePath(Config.outputFolder, dir) : "";
+        string newFilePath = NamingFormat(filepath, Config.nameFormat, track);
 
         if (filepath != newFilePath)
         {
             dir = Path.GetDirectoryName(newFilePath) ?? "";
-            if (dir != "") Directory.CreateDirectory(dir);
+            if (dir.Length > 0) Directory.CreateDirectory(dir);
 
             try
             {
@@ -3739,8 +1167,8 @@ static class Program
                 return filepath;
             }
 
-            if (add != "" && add != "." && Utils.GetRecursiveFileCount(Path.Join(outputFolder, add)) == 0)
-                try { Directory.Delete(Path.Join(outputFolder, add), true); } catch { }
+            if (add.Length > 0 && add != "." && Utils.GetRecursiveFileCount(Path.Join(Config.outputFolder, add)) == 0)
+                try { Directory.Delete(Path.Join(Config.outputFolder, add), true); } catch { }
         }
 
         return newFilePath;
@@ -3762,7 +1190,7 @@ static class Program
             foreach (Match match in matches.Cast<Match>())
             {
                 string inner = match.Groups[1].Value;
-                inner = inner.Substring(1, inner.Length - 2);
+                inner = inner[1..^1];
 
                 var options = inner.Split('|');
                 string chosenOpt = "";
@@ -3771,7 +1199,8 @@ static class Program
                 {
                     string[] parts = Regex.Split(opt, @"\([^\)]*\)");
                     string[] result = parts.Where(part => !string.IsNullOrWhiteSpace(part)).ToArray();
-                    if (result.All(x => GetVarValue(x, file, filepath, track) != "")) {
+                    if (result.All(x => GetVarValue(x, file, filepath, track).Length > 0))
+                    {
                         chosenOpt = opt;
                         break;
                     }
@@ -3780,13 +1209,13 @@ static class Program
                 chosenOpt = Regex.Replace(chosenOpt, @"\([^()]*\)|[^()]+", match =>
                 {
                     if (match.Value.StartsWith("(") && match.Value.EndsWith(")"))
-                        return match.Value.Substring(1, match.Value.Length-2).ReplaceInvalidChars(invalidReplaceStr, removeSlash: false);
+                        return match.Value[1..^1].ReplaceInvalidChars(Config.invalidReplaceStr, removeSlash: false);
                     else
-                        return GetVarValue(match.Value, file, filepath, track).ReplaceInvalidChars(invalidReplaceStr);
+                        return GetVarValue(match.Value, file, filepath, track).ReplaceInvalidChars(Config.invalidReplaceStr);
                 });
 
                 string old = match.Groups[1].Value;
-                old = old.StartsWith("{{") ? old.Substring(1) : old;
+                old = old.StartsWith("{{") ? old[1..] : old;
                 newName = newName.Replace(old, chosenOpt);
             }
 
@@ -3800,7 +1229,7 @@ static class Program
             char dirsep = Path.DirectorySeparatorChar;
             newName = newName.Replace('/', dirsep);
             var x = newName.Split(dirsep, StringSplitOptions.RemoveEmptyEntries);
-            newName = string.Join(dirsep, x.Select(x => x.ReplaceInvalidChars(invalidReplaceStr).Trim(' ', '.')));
+            newName = string.Join(dirsep, x.Select(x => x.ReplaceInvalidChars(Config.invalidReplaceStr).Trim(' ', '.')));
             string newFilePath = Path.Combine(directory, newName + extension);
             return newFilePath;
         }
@@ -3840,496 +1269,36 @@ static class Program
             case "filename":
                 return Path.GetFileNameWithoutExtension(filepath);
             case "foldername":
-                return defaultFolderName;
+                return Config.defaultFolderName;
+            case "extractor":
+                return Config.inputType.ToString();
             default:
                 return "";
         }
     }
 
-    static bool TrackMatchesFilename(Track track, string filename)
-    {
-        if (track.Title.Trim() == "" || filename.Trim() == "")
-            return false;
-
-        string[] ignore = new string[] { " ", "_", "-", ".", "(", ")", "[", "]" };
-
-        string preprocess1(string s, bool removeSlash = true)
-        {
-            s = s.ReplaceInvalidChars("", false, removeSlash).Replace(ignore, "").ToLower();
-            s = s.RemoveFt().RemoveDiacritics();
-            return s;
-        }
-
-        string preprocess2(string s, bool removeSlash = true)
-        {
-            s = s.ReplaceInvalidChars("", false, removeSlash).ToLower().RemoveDiacritics();
-            return s;
-        }
-
-        string preprocess3(string s)
-        {
-            s = s.ToLower().RemoveDiacritics();
-            return s;
-        }
-
-        string title = preprocess1(track.Title);
-        string artist = preprocess1(track.Artist);
-        string fname = preprocess1(Path.GetFileNameWithoutExtension(filename));
-        string path = preprocess1(filename, false);
-
-        if (title == "" || fname == "")
-        {
-            title = preprocess2(track.Title);
-            artist = preprocess2(track.Artist);
-            fname = preprocess2(Path.GetFileNameWithoutExtension(filename));
-            path = preprocess2(filename, false);
-
-            if (title == "" || fname == "")
-            {
-                title = preprocess3(track.Title);
-                artist = preprocess3(track.Artist);
-                fname = preprocess3(Path.GetFileNameWithoutExtension(filename));
-                path = preprocess3(filename);
-
-                if (title == "" || fname == "")
-                {
-                    return false;
-                }
-            }
-        }
-
-        if (fname.Contains(title) && path.Contains(artist))
-        {
-            return true;
-        }
-        else if ((track.ArtistMaybeWrong || track.Artist == "") && track.Title.Contains(" - "))
-        {
-            title = preprocess1(track.Title.Substring(track.Title.IndexOf(" - ") + 3));
-            if (title != "")
-            {
-                if (preprocess1(filename, false).Contains(title))
-                    return true;
-            }
-        }
-
-        return false;
-    }
-
-    static bool TrackExistsInCollection(Track track, FileConditions conditions, IEnumerable<string> collection, out string? foundPath, bool precise)
-    {
-        var matchingFiles = collection.Where(fileName => TrackMatchesFilename(track, fileName)).ToArray();
-
-        if (!precise && matchingFiles.Any())
-        {
-            foundPath = matchingFiles.First();
-            return true;
-        }
-
-        foreach (var p in matchingFiles)
-        {
-            TagLib.File f;
-            try { f = TagLib.File.Create(p); }
-            catch { continue; }
-
-            if (conditions.FileSatisfies(f, track))
-            {
-                foundPath = p;
-                return true;
-            }
-        }
-
-        foundPath = null;
-        return false;
-    }
-
-    static bool TrackExistsInCollection(Track track, FileConditions conditions, IEnumerable<TagLib.File> collection, out string? foundPath, bool precise)
-    {
-        string artist = track.Artist.ToLower().Replace(" ", "").RemoveFt();
-        string title = track.Title.ToLower().Replace(" ", "").RemoveFt().RemoveSquareBrackets();
-
-        foreach (var f in collection)
-        {
-            foundPath = f.Name;
-
-            if (precise && !conditions.FileSatisfies(f, track))
-                continue;
-            if (string.IsNullOrEmpty(f.Tag.Title) || string.IsNullOrEmpty(f.Tag.FirstPerformer))
-            {
-                if (TrackMatchesFilename(track, f.Name))
-                    return true;
-                continue;
-            }
-
-            string fileArtist = f.Tag.FirstPerformer.ToLower().Replace(" ", "").RemoveFt();
-            string fileTitle = f.Tag.Title.ToLower().Replace(" ", "").RemoveFt().RemoveSquareBrackets();
-
-            bool durCheck = conditions.LengthToleranceSatisfies(f, track.Length);
-            bool check1 = (artist.Contains(fileArtist) || (track.ArtistMaybeWrong && title.Contains(fileArtist)));
-            bool check2 = !precise && fileTitle.Length >= 6 && durCheck;
-
-            if ((check1 || check2) && (precise || conditions.DangerWordSatisfies(fileTitle, title, artist)))
-            {
-                if (title.Contains(fileTitle))
-                    return true;
-            }
-        }
-
-        foundPath = null;
-        return false;
-    }
-
-    static Dictionary<Track, string> SkipExisting(List<Track> tracks, string dir, FileConditions necessaryCond, SkipMode mode, bool useCache)
-    {
-        var existing = new Dictionary<Track, string>();
-        List<string> musicFiles;
-        List<TagLib.File> musicIndex;
-        bool useTags = mode == SkipMode.Tag || mode == SkipMode.TagPrecise;
-        bool precise = mode == SkipMode.NamePrecise || mode == SkipMode.TagPrecise;
-
-        if (useCache && MusicCache.TryGetValue(dir, out var cached))
-        {
-            musicFiles = cached.musicFiles;
-            musicIndex = cached.musicIndex;
-        }
-        else
-        {
-            var files = System.IO.Directory.GetFiles(dir, "*", SearchOption.AllDirectories);
-            musicFiles = files.Where(filename => Utils.IsMusicFile(filename)).ToList();
-            musicIndex = useTags ? BuildMusicIndex(musicFiles) : new List<TagLib.File>();
-            if (useCache)
-                MusicCache[dir] = (musicFiles, musicIndex);
-        }
-
-        for (int i = 0; i < tracks.Count; i++)
-        {
-            if (tracks[i].IsNotAudio)
-                continue;
-            bool exists;
-            string? path;
-            if (useTags)
-                exists = TrackExistsInCollection(tracks[i], necessaryCond, musicIndex, out path, precise);
-            else
-                exists = TrackExistsInCollection(tracks[i], necessaryCond, musicFiles, out path, precise);
-
-            if (exists)
-            {
-                existing.TryAdd(tracks[i], path);
-                tracks[i] = new Track(tracks[i]) { TrackState = Track.State.Exists, DownloadPath = path };
-            }
-        }
-
-        return existing;
-    }
-
-    static Dictionary<Track, string> SkipExistingM3u(List<Track> tracks)
-    {
-        var existing = new Dictionary<Track, string>();
-
-        for (int i = 0; i < tracks.Count; i++)
-        {
-            if (!m3uEditor.HasFail(tracks[i], out _))
-            {
-                existing.TryAdd(tracks[i], "");
-                tracks[i] = new Track(tracks[i]) { TrackState = Track.State.Exists, DownloadPath = "" };
-            }
-        }
-
-        return existing;
-    }
-
-    static List<TagLib.File> BuildMusicIndex(List<string> musicFiles)
-    {
-        var musicIndex = new List<TagLib.File>();
-        foreach (var p in musicFiles)
-        {
-            try { musicIndex.Add(TagLib.File.Create(p)); }
-            catch { continue; }
-        }
-        return musicIndex;
-    }
-
-    static Dictionary<string, (List<string> musicFiles, List<TagLib.File> musicIndex)> MusicCache = new();
-
-    static List<string> ParseConfig(string path)
-    {
-        var lines = File.ReadAllLines(path);
-        var res = new List<string>();
-        foreach (var line in lines)
-        {
-            string l = line.Trim();
-            if (l == "" || l.StartsWith('#'))
-                continue;
-
-            int i = l.IndexOfAny(new char[] { ' ', '=' });
-
-            if (i < 0) continue;
-
-            var x = l.Split(l[i], 2, StringSplitOptions.TrimEntries);
-            string opt = x[0];
-            string arg = x[1];
-
-            if (opt == "") continue;
-
-            if (arg.StartsWith('='))
-                arg = arg.Substring(1).TrimStart();
-
-            if (arg.Length > 0 && arg[0] == '"' && arg[arg.Length - 1] == '"')
-                arg = arg.Substring(1, arg.Length - 2);
-
-            if (arg == "false") continue;
-
-            if (!opt.StartsWith('-'))
-            {
-                if (opt.Length == 1)
-                    opt = '-' + opt;
-                else
-                    opt = "--" + opt;
-            }
-
-            res.Add(opt);
-
-            if (arg.Length > 0 && arg != "true")
-                res.Add(arg);
-        }
-        return res;
-    }
-
-    static void ParseConditions(FileConditions cond, string input)
-    {
-        var tr = StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries;
-        string[] conditions = input.Split(';', tr);
-        foreach (string condition in conditions)
-        {
-            string[] parts = condition.Split(new string[] { ">=", "<=", "=", ">", "<" }, 2, tr);
-            string field = parts[0].Replace("-", "").Trim().ToLower();
-            string value = parts.Length > 1 ? parts[1].Trim() : "true";
-
-            switch (field)
-            {
-                case "sr":
-                case "samplerate":
-                    UpdateMinMax(value, condition, ref cond.MinSampleRate, ref cond.MaxSampleRate);
-                    break;
-                case "br":
-                case "bitrate":
-                    UpdateMinMax(value, condition, ref cond.MinBitrate, ref cond.MaxBitrate);
-                    break;
-                case "bd":
-                case "bitdepth":
-                    UpdateMinMax(value, condition, ref cond.MinBitDepth, ref cond.MaxBitDepth);
-                    break;
-                case "t":
-                case "tol":
-                case "lentol":
-                case "lengthtol":
-                case "tolerance":
-                case "lengthtolerance":
-                    cond.LengthTolerance = int.Parse(value);
-                    break;
-                case "f":
-                case "format":
-                case "formats":
-                    cond.Formats = value.Split(',', tr);
-                    break;
-                case "banned":
-                case "bannedusers":
-                    cond.BannedUsers = value.Split(',', tr);
-                    break;
-                case "dangerwords":
-                    cond.DangerWords = value.Split(',', tr);
-                    break;
-                case "stricttitle":
-                    cond.StrictTitle = bool.Parse(value);
-                    break;
-                case "strictartist":
-                    cond.StrictArtist = bool.Parse(value);
-                    break;
-                case "strictalbum":
-                    cond.StrictAlbum = bool.Parse(value);
-                    break;
-                case "acceptnolen":
-                case "acceptnolength":
-                    cond.AcceptNoLength = bool.Parse(value);
-                    break;
-                case "strict":
-                case "acceptmissing":
-                case "acceptmissingprops":
-                    cond.AcceptMissingProps = bool.Parse(value);
-                    break;
-                default:
-                    throw new ArgumentException($"Unknown condition '{condition}'");
-            }
-        }
-    }
-
-
-    static void UpdateMinMax(string value, string condition, ref int min, ref int max)
-    {
-        if (condition.Contains(">="))
-            min = int.Parse(value);
-        else if (condition.Contains("<="))
-            max = int.Parse(value);
-        else if (condition.Contains('>'))
-            min = int.Parse(value) + 1;
-        else if (condition.Contains('<'))
-            max = int.Parse(value) - 1;
-        else if (condition.Contains('='))
-            min = max = int.Parse(value);
-    }
-
-
-    static Track ParseTrackArg(string input, bool isAlbum)
-    {
-        input = input.Trim();
-        var track = new Track();
-        var keys = new string[] { "title", "artist", "duration", "length", "album", "artist-maybe-wrong" };
-
-        track.IsAlbum = isAlbum;
-
-        var parts = input.Split(',');
-        var other = "";
-        var lastkeyval = true;
-
-        for (int i = 0; i < parts.Length; i++)
-        {
-            var x = parts[i];
-            bool keyval = false;
-
-            if (x.Contains('='))
-            {
-                var lr = x.Split('=', 2, StringSplitOptions.TrimEntries);
-                if (lr.Length == 2 && lr[1] != "" && keys.Contains(lr[0]))
-                {
-                    keyval = true;
-                    switch (lr[0])
-                    {
-                        case "title":
-                            track.Title = lr[1];
-                            break;
-                        case "artist":
-                            track.Artist = lr[1];
-                            break;
-                        case "duration":
-                        case "length":
-                            track.Length = int.Parse(lr[1]);
-                            break;
-                        case "album":
-                            track.Album = lr[1];
-                            break;
-                        case "artist-maybe-wrong":
-                            if (lr[1] == "true")
-                                track.ArtistMaybeWrong = true;
-                            break;
-                    }
-                }
-            }
-
-            if (!keyval)
-            {
-                if (!lastkeyval)
-                    other += ',';
-                other += x;
-                lastkeyval = false;
-            }
-            else
-            {
-                lastkeyval = true;
-            }
-        }
-
-        string artist = "", album = "", title = "";
-        string splitBy = other.Contains(" -- ") ? " -- " : " - ";
-        parts = other.Split(splitBy, StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries);
-        if (parts.Length == 1 || parts.Length > 3)
-        {
-            if (isAlbum) 
-                album = other.Trim();
-            else 
-                title = other.Trim();
-        }
-        else if (parts.Length == 2)
-        {
-            artist = parts[0];
-
-            if (isAlbum)
-                album = parts[1];
-            else
-                title = parts[1];
-        }
-        else if (parts.Length == 3)
-        {
-            artist = parts[0];
-            album = parts[1];
-            title = parts[2];
-        }
-
-        if (track.Artist == "")
-            track.Artist = artist;
-        if (track.Album == "")
-            track.Album = album;
-        if (track.Title == "")
-            track.Title = title;
-
-        if (track.Title == "" && track.Album == "" && track.Artist == "")
-            throw new ArgumentException("Track string must contain title, album or artist.");
-
-        return track;
-    }
-
-    static double ParseTrackLength(string duration, string format)
-    {
-        if (string.IsNullOrEmpty(format))
-            throw new ArgumentException("Duration format string empty");
-        duration = Regex.Replace(duration, "[a-zA-Z]", "");
-        var formatParts = Regex.Split(format, @"\W+");
-        var durationParts = Regex.Split(duration, @"\W+").Where(s => !string.IsNullOrEmpty(s)).ToArray();
-
-        double totalSeconds = 0;
-
-        for (int i = 0; i < formatParts.Length; i++)
-        {
-            switch (formatParts[i])
-            {
-                case "h":
-                    totalSeconds += double.Parse(durationParts[i]) * 3600;
-                    break;
-                case "m":
-                    totalSeconds += double.Parse(durationParts[i]) * 60;
-                    break;
-                case "s":
-                    totalSeconds += double.Parse(durationParts[i]);
-                    break;
-                case "ms":
-                    totalSeconds += double.Parse(durationParts[i]) / Math.Pow(10, durationParts[i].Length);
-                    break;
-            }
-        }
-
-        return totalSeconds;
-    }
-
-    static string DisplayString(Track t, Soulseek.File? file=null, SearchResponse? response=null, FileConditions? nec=null, 
-        FileConditions? pref=null, bool fullpath=false, string customPath="", bool infoFirst=false, bool showUser=true, bool showSpeed=false)
+    static string DisplayString(Track t, Soulseek.File? file = null, SearchResponse? response = null, FileConditions? nec = null,
+        FileConditions? pref = null, bool fullpath = false, string customPath = "", bool infoFirst = false, bool showUser = true, bool showSpeed = false)
     {
         if (file == null)
             return t.ToString();
 
-        string sampleRate = file.SampleRate.HasValue ? $"{(file.SampleRate.Value/1000.0).Normalize()}kHz" : "";
+        string sampleRate = file.SampleRate.HasValue ? $"{(file.SampleRate.Value / 1000.0).Normalize()}kHz" : "";
         string bitRate = file.BitRate.HasValue ? $"{file.BitRate}kbps" : "";
         string fileSize = $"{file.Size / (float)(1024 * 1024):F1}MB";
         string user = showUser && response?.Username != null ? response.Username + "\\" : "";
         string speed = showSpeed && response?.Username != null ? $"({response.UploadSpeed / 1024.0 / 1024.0:F2}MB/s) " : "";
-        string fname = fullpath ? file.Filename : (showUser ? "..\\" : "") + (customPath == "" ? GetFileNameSlsk(file.Filename) : customPath);
+        string fname = fullpath ? file.Filename : (showUser ? "..\\" : "") + (customPath.Length == 0 ? Utils.GetFileNameSlsk(file.Filename) : customPath);
         string length = Utils.IsMusicFile(file.Filename) ? (file.Length ?? -1).ToString() + "s" : "";
         string displayText;
         if (!infoFirst)
         {
-            string info = string.Join('/', new string[] { length, sampleRate+bitRate, fileSize }.Where(value => value!=""));
+            string info = string.Join('/', new string[] { length, sampleRate + bitRate, fileSize }.Where(value => value.Length > 0));
             displayText = $"{speed}{user}{fname} [{info}]";
         }
         else
         {
-            string info = string.Join('/', new string[] { length.PadRight(4), (sampleRate+bitRate).PadRight(8), fileSize.PadLeft(6) });
+            string info = string.Join('/', new string[] { length.PadRight(4), (sampleRate + bitRate).PadRight(8), fileSize.PadLeft(6) });
             displayText = $"[{info}] {speed}{user}{fname}";
         }
 
@@ -4342,57 +1311,64 @@ static class Program
         return displayText + cond;
     }
 
-    static void PrintTracks(List<Track> tracks, int number = int.MaxValue, bool fullInfo=false, bool pathsOnly=false, bool showAncestors=false, bool infoFirst=false, bool showUser=true)
+    static void PrintTracks(List<Track> tracks, int number = int.MaxValue, bool fullInfo = false, bool pathsOnly = false, bool showAncestors = false, bool infoFirst = false, bool showUser = true)
     {
         number = Math.Min(tracks.Count, number);
 
         string ancestor = "";
 
         if (showAncestors)
-            ancestor = Utils.GreatestCommonPath(tracks.SelectMany(x => x.Downloads.Select(y => y.Value.Item2.Filename)));
+            ancestor = Utils.GreatestCommonPath(tracks.SelectMany(x => x.Downloads.Select(y => y.Value.Item2.Filename)), Path.DirectorySeparatorChar);
 
-        if (pathsOnly) 
+        if (pathsOnly)
         {
             for (int i = 0; i < number; i++)
             {
                 foreach (var x in tracks[i].Downloads)
                 {
-                    if (ancestor == "")
+                    if (ancestor.Length == 0)
                         Console.WriteLine("    " + DisplayString(tracks[i], x.Value.Item2, x.Value.Item1, infoFirst: infoFirst, showUser: showUser));
                     else
                         Console.WriteLine("    " + DisplayString(tracks[i], x.Value.Item2, x.Value.Item1, customPath: x.Value.Item2.Filename.Replace(ancestor, ""), infoFirst: infoFirst, showUser: showUser));
                 }
             }
         }
-        else if (!fullInfo) 
+        else if (!fullInfo)
         {
             for (int i = 0; i < number; i++)
             {
                 Console.WriteLine($"  {tracks[i]}");
             }
         }
-        else 
+        else
         {
-            for (int i = 0; i < number; i++) 
+            for (int i = 0; i < number; i++)
             {
                 if (!tracks[i].IsNotAudio)
                 {
-                    Console.WriteLine($"  Title:              {tracks[i].Title}");
                     Console.WriteLine($"  Artist:             {tracks[i].Artist}");
-                    if (!tracks[i].IsAlbum)
-                        Console.WriteLine($"  Length:             {tracks[i].Length}s");
-                    if (!string.IsNullOrEmpty(tracks[i].Album))
+                    if (!string.IsNullOrEmpty(tracks[i].Title) || !tracks[i].IsAlbum)
+                        Console.WriteLine($"  Title:              {tracks[i].Title}");
+                    if (!string.IsNullOrEmpty(tracks[i].Album) || tracks[i].IsAlbum)
                         Console.WriteLine($"  Album:              {tracks[i].Album}");
+                    if (tracks[i].Length > -1 || !tracks[i].IsAlbum)
+                        Console.WriteLine($"  Length:             {tracks[i].Length}s");
+                    if (!string.IsNullOrEmpty(tracks[i].DownloadPath))
+                        Console.WriteLine($"  Local path:         {tracks[i].DownloadPath}");
                     if (!string.IsNullOrEmpty(tracks[i].URI))
                         Console.WriteLine($"  URL/ID:             {tracks[i].URI}");
+                    if (tracks[i].IsAlbum)
+                        Console.WriteLine($"  Is album:           true");
                     if (!string.IsNullOrEmpty(tracks[i].Other))
                         Console.WriteLine($"  Other:              {tracks[i].Other}");
                     if (tracks[i].ArtistMaybeWrong)
-                        Console.WriteLine($"  Artist maybe wrong: {tracks[i].ArtistMaybeWrong}");    
-                    if (tracks[i].Downloads != null) {
+                        Console.WriteLine($"  Artist maybe wrong: {tracks[i].ArtistMaybeWrong}");
+                    if (tracks[i].Downloads != null)
+                    {
                         Console.WriteLine($"  Shares:             {tracks[i].Downloads.Count}");
-                        foreach (var x in tracks[i].Downloads) {
-                            if (ancestor == "")
+                        foreach (var x in tracks[i].Downloads)
+                        {
+                            if (ancestor.Length == 0)
                                 Console.WriteLine("    " + DisplayString(tracks[i], x.Value.Item2, x.Value.Item1, infoFirst: infoFirst, showUser: showUser));
                             else
                                 Console.WriteLine("    " + DisplayString(tracks[i], x.Value.Item2, x.Value.Item1, customPath: x.Value.Item2.Filename.Replace(ancestor, ""), infoFirst: infoFirst, showUser: showUser));
@@ -4402,10 +1378,11 @@ static class Program
                 }
                 else
                 {
-                    Console.WriteLine($"  File:               {GetFileNameSlsk(tracks[i].Downloads.First().Value.Item2.Filename)}");
+                    Console.WriteLine($"  File:               {Utils.GetFileNameSlsk(tracks[i].Downloads.First().Value.Item2.Filename)}");
                     Console.WriteLine($"  Shares:             {tracks[i].Downloads.Count}");
-                    foreach (var x in tracks[i].Downloads) {
-                        if (ancestor == "")
+                    foreach (var x in tracks[i].Downloads)
+                    {
+                        if (ancestor.Length == 0)
                             Console.WriteLine("    " + DisplayString(tracks[i], x.Value.Item2, x.Value.Item1, infoFirst: infoFirst, showUser: showUser));
                         else
                             Console.WriteLine("    " + DisplayString(tracks[i], x.Value.Item2, x.Value.Item1, customPath: x.Value.Item2.Filename.Replace(ancestor, ""), infoFirst: infoFirst, showUser: showUser));
@@ -4427,13 +1404,13 @@ static class Program
             try { progress.Refresh(current, item); }
             catch { }
         }
-        else if ((displayStyle == "simple" || Console.IsOutputRedirected) && print)
+        else if ((Config.displayMode == DisplayMode.Simple || Console.IsOutputRedirected) && print)
             Console.WriteLine(item);
     }
 
-    public static void WriteLine(string value, ConsoleColor color=ConsoleColor.Gray, bool safe=false, bool debugOnly=false)
+    public static void WriteLine(string value, ConsoleColor color = ConsoleColor.Gray, bool safe = false, bool debugOnly = false)
     {
-        if (debugOnly && !debugInfo)
+        if (debugOnly && !Config.debugInfo)
             return;
         if (!safe)
         {
@@ -4450,25 +1427,19 @@ static class Program
                 Console.WriteLine(value);
                 Console.ResetColor();
             }
+
             skipUpdate = false;
         }
     }
 
-    private static ProgressBar? GetProgressBar(string style)
+    public static ProgressBar? GetProgressBar(DisplayMode style)
     {
         lock (consoleLock)
         {
-#if WINDOWS
-            if (!debugDisableDownload && debugPrintTracks)
-            {
-                try { Console.BufferHeight = Math.Max(Console.BufferHeight + 2, 4000); }
-                catch { }
-            }
-#endif
             ProgressBar? progress = null;
-            if (style == "double")
+            if (style == DisplayMode.Double)
                 progress = new ProgressBar(PbStyle.DoubleLine, 100, Console.WindowWidth - 40, character: '―');
-            else if (style != "simple")
+            else if (style != DisplayMode.Simple)
                 progress = new ProgressBar(PbStyle.SingleLine, 100, Console.WindowWidth - 10, character: ' ');
             return progress;
         }
@@ -4479,13 +1450,18 @@ static class Program
         while (true)
         {
             WriteLine($"Wait for login, state: {client.State}", debugOnly: true);
-            if (client.State.HasFlag(SoulseekClientStates.LoggedIn))
+            if (IsConnectedAndLoggedIn())
                 break;
-            await Task.Delay(500);
+            await Task.Delay(1000);
         }
     }
 
-    static List<string> bannedTerms = new List<string>()
+    public static bool IsConnectedAndLoggedIn()
+    {
+        return client != null && (client.State & (SoulseekClientStates.Connected | SoulseekClientStates.LoggedIn)) != 0;
+    }
+
+    static readonly List<string> bannedTerms = new()
     {
         "depeche mode", "beatles", "prince revolutions", "michael jackson", "coexist", "bob dylan", "enter shikari",
         "village people", "lenny kravitz", "beyonce", "beyoncé", "lady gaga", "jay z", "kanye west", "rihanna",
@@ -4495,493 +1471,3 @@ static class Program
 }
 
 
-public enum FailureReasons
-{
-    None,
-    InvalidSearchString,
-    OutOfDownloadRetries,
-    NoSuitableFileFound,
-    AllDownloadsFailed
-}
-
-
-public class TrackLists
-{
-    public enum ListType
-    {
-        Normal,
-        Album,
-        Aggregate
-    }
-
-    public List<(List<List<Track>> list, ListType type, Track source)> lists = new();
-
-    public TrackLists() { }
-
-    public TrackLists(List<(List<List<Track>> list, ListType type, Track source)> lists)
-    {
-        foreach (var (list, type, source) in lists)
-        {
-            var newList = new List<List<Track>>();
-            foreach (var innerList in list)
-            {
-                var innerNewList = new List<Track>(innerList);
-                newList.Add(innerNewList);
-            }
-            this.lists.Add((newList, type, source));
-        }
-    }
-
-    public static TrackLists FromFlatList(List<Track> flatList, bool aggregate, bool album)
-    {
-        var res = new TrackLists();
-        for (int i = 0; i < flatList.Count; i++)
-        {
-            if (aggregate)
-            {
-                res.AddEntry(ListType.Aggregate, flatList[i]);
-            }
-            else if (album || (flatList[i].Album != "" && flatList[i].Title == ""))
-            {
-                res.AddEntry(ListType.Album, new Track(flatList[i]) { IsAlbum = true });
-            }
-            else
-            {
-                res.AddEntry(ListType.Normal);
-                while (i < flatList.Count && (flatList[i].Album == "" || flatList[i].Title != ""))
-                {
-                    res.AddTrackToLast(flatList[i]);
-                    i++;
-                }
-                if (i < flatList.Count)
-                    i--;
-            }
-        }
-        return res;
-    }
-
-    public void AddEntry(List<List<Track>>? list=null, ListType? type=null, Track? source=null)
-    {
-        type ??= ListType.Normal;
-        source ??= new Track();
-        list ??= new List<List<Track>>();
-        lists.Add(((List<List<Track>> list, ListType type, Track source))(list, type, source));
-    }
-
-    public void AddEntry(List<Track> tracks, ListType? type = null, Track? source = null)
-    {
-        var list = new List<List<Track>>() { tracks };
-        AddEntry(list, type, source);
-    }
-
-    public void AddEntry(Track track, ListType? type = null, Track? source = null)
-    {
-        var list = new List<List<Track>>() { new List<Track>() { track } };
-        AddEntry(list, type, source);
-    }
-
-    public void AddEntry(ListType? type = null, Track? source = null)
-    {
-        var list = new List<List<Track>>() { new List<Track>() };
-        AddEntry(list, type, source);
-    }
-
-    public void AddTrackToLast(Track track)
-    {
-        int i = lists.Count - 1;
-        int j = lists[i].list.Count - 1;
-        lists[i].list[j].Add(track);
-    }
-
-    public void Reverse()
-    {
-        lists.Reverse();
-        foreach (var (list, type, source) in lists)
-        {
-            foreach (var ls in list)
-            {
-                ls.Reverse();
-            }
-        }
-    }
-
-    public List<Track> CombinedTrackList(bool addSourceTracks=false)
-    {
-        var res = new List<Track>();
-
-        foreach (var (list, type, source) in lists)
-        {
-            if (addSourceTracks)
-                res.Add(source);
-            foreach (var t in list[0])
-                res.Add(t);
-        }
-
-        return res;
-    }
-
-    public List<Track> Flattened()
-    {
-        var res = new List<Track>();
-
-        foreach (var (list, type, source) in lists)
-        {
-            if (type == ListType.Album || type == ListType.Aggregate)
-            {
-                res.Add(source);
-            }
-            else
-            {
-                foreach (var t in list[0])
-                    res.Add(t);
-            }
-        }
-
-        return res;
-    }
-
-    public void SetList(List<List<Track>> list, int index)
-    {
-        var (_, type, source) = lists[index];
-        lists[index] = (list, type, source);
-    }
-
-    public void SetType(ListType type, int index)
-    {
-        var (list, _, source) = lists[index];
-        lists[index] = (list, type, source);
-    }
-
-    public void SetSource(Track source, int index)
-    {
-        var (list, type, _) = lists[index];
-        lists[index] = (list, type, source);
-    }
-}
-
-
-public struct Track
-{
-    public string Title = "";
-    public string Artist = "";
-    public string Album = "";
-    public string URI = "";
-    public int Length = -1;
-    public bool ArtistMaybeWrong = false;
-    public bool IsAlbum = false;
-    public int MinAlbumTrackCount = -1;
-    public int MaxAlbumTrackCount = -1;
-    public bool IsNotAudio = false;
-    public string FailureReason = "";
-    public string DownloadPath = "";
-    public string Other = "";
-    public int CsvRow = -1; 
-    public State TrackState = State.Initial;
-
-    public SlDictionary? Downloads = null;
-
-    public enum State
-    {
-        Initial,
-        Downloaded, 
-        Failed,
-        Exists,
-        NotFoundLastTime
-    };
-
-    public Track() { }
-
-    public Track(Track other)
-    {
-        Title = other.Title;
-        Artist = other.Artist;
-        Album = other.Album;
-        Length = other.Length;
-        URI = other.URI;
-        ArtistMaybeWrong = other.ArtistMaybeWrong;
-        Downloads = other.Downloads;
-        IsAlbum = other.IsAlbum;
-        IsNotAudio = other.IsNotAudio;
-        TrackState = other.TrackState;
-        FailureReason = other.FailureReason;
-        DownloadPath = other.DownloadPath;
-        Other = other.Other;
-        MinAlbumTrackCount = other.MinAlbumTrackCount;
-        MaxAlbumTrackCount = other.MaxAlbumTrackCount;
-        CsvRow = other.CsvRow;
-    }
-
-    public override readonly string ToString()
-    {
-        return ToString(false);
-    }
-
-    public readonly string ToString(bool noInfo = false)
-    {
-        if (IsNotAudio && Downloads != null && !Downloads.IsEmpty)
-            return $"{Program.GetFileNameSlsk(Downloads.First().Value.Item2.Filename)}";
-
-        string str = Artist;
-        if (!IsAlbum && Title == "" && Downloads != null && !Downloads.IsEmpty)
-        {
-            str = $"{Program.GetFileNameSlsk(Downloads.First().Value.Item2.Filename)}";
-        }
-        else if (Title != "" || Album != "")
-        {
-            if (str != "")
-                str += " - ";
-            if (IsAlbum)
-                str += Album;
-            else if (Title != "")
-                str += Title;
-            if (!noInfo)
-            {
-                if (Length > 0)
-                    str += $" ({Length}s)";
-                if (IsAlbum)
-                    str += " (album)";
-            }
-        }
-        else if (!noInfo)
-        {
-            str += " (artist)";
-        }
-
-        return str;
-    }
-}
-
-
-class TrackStringComparer : IEqualityComparer<Track>
-{
-    private bool _ignoreCase = false;
-    public TrackStringComparer(bool ignoreCase = false) {
-        _ignoreCase = ignoreCase;
-    }
-
-    public bool Equals(Track a, Track b)
-    {
-        if (a.Equals(b))
-            return true;
-
-        var comparer = _ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
-
-        return string.Equals(a.Title, b.Title, comparer)
-            && string.Equals(a.Artist, b.Artist, comparer)
-            && string.Equals(a.Album, b.Album, comparer);
-    }
-
-    public int GetHashCode(Track a)
-    {
-        unchecked
-        {
-            int hash = 17;
-            string trackTitle = _ignoreCase ? a.Title.ToLower() : a.Title;
-            string artistName = _ignoreCase ? a.Artist.ToLower() : a.Artist;
-            string album = _ignoreCase ? a.Album.ToLower() : a.Album;
-
-            hash = hash * 23 + trackTitle.GetHashCode();
-            hash = hash * 23 + artistName.GetHashCode();
-            hash = hash * 23 + album.GetHashCode();
-
-            return hash;
-        }
-    }
-}
-
-
-public class M3UEditor
-{
-    public TrackLists trackLists;
-    public string path;
-    public string outputFolder;
-    public int offset = 0;
-    public string option = "fails";
-    public bool m3uListLabels = false;
-    public Dictionary<string, string> fails;
-
-    public M3UEditor(string m3uPath, string outputFolder, TrackLists trackLists, int offset = 0, string option="fails")
-    {
-        this.trackLists = trackLists;
-        this.outputFolder = Path.GetFullPath(outputFolder);
-        this.offset = offset;
-        this.option = option;
-        path = Path.GetFullPath(m3uPath);
-
-        var lines = ReadAllLines();
-        fails = lines.Where(x => x.StartsWith("# Failed: "))
-            .Select(line =>
-            {
-                var lastBracketIndex = line.LastIndexOf('[');
-                lastBracketIndex = lastBracketIndex == -1 ? line.Length : lastBracketIndex;
-                var key = line.Substring("# Failed: ".Length, lastBracketIndex - "# Failed: ".Length).Trim();
-                var value = lastBracketIndex != line.Length ? line.Substring(lastBracketIndex + 1).Trim().TrimEnd(']') : "";
-                return new { Key = key, Reason = value };
-            })
-            .ToSafeDictionary(pair => pair.Key, pair => pair.Reason);
-    }
-
-    public void Update()
-    {
-        if (option != "fails" && option != "all")
-            return;
-
-        bool needUpdate = false;
-
-        lock (trackLists)
-        {
-            var lines = ReadAllLines().ToList();
-            int index = offset;
-
-            void updateLine(string newLine)
-            {
-                while (index >= lines.Count) lines.Add("");
-                if (newLine != lines[index]) needUpdate = true;
-                lines[index] = newLine;
-            }
-
-            foreach (var (list, type, source) in trackLists.lists)
-            {
-                if (source.TrackState == Track.State.Failed)
-                {
-                    updateLine(TrackToLine(source, source.FailureReason));
-                    fails.TryAdd(source.ToString().Trim(), source.FailureReason.Trim());
-                    index++;
-                }
-                else
-                {
-                    if (m3uListLabels)
-                    {
-                        string end = type == TrackLists.ListType.Normal ? "" : $" {source.ToString(noInfo: true)}";
-                        updateLine($"# {Enum.GetName(typeof(TrackLists.ListType), type)} download{end}");
-                        index++;
-                    }
-                    for (int k = 0; k < list.Count; k++)
-                    {
-                        for (int j = 0; j < list[k].Count; j++)
-                        {
-                            var track = list[k][j];
-                            if (track.IsNotAudio)
-                            {
-                                continue;
-                            }
-                            else if (track.TrackState == Track.State.Failed || track.TrackState == Track.State.NotFoundLastTime ||
-                                (option == "all" && (track.TrackState == Track.State.Downloaded || (track.TrackState == Track.State.Exists && k == 0))))
-                            {
-                                string reason = track.TrackState == Track.State.NotFoundLastTime ? nameof(FailureReasons.NoSuitableFileFound) : track.FailureReason;
-                                updateLine(TrackToLine(track, reason));
-                                if (track.TrackState == Track.State.Failed)
-                                    fails.TryAdd(track.ToString().Trim(), reason.Trim());
-                                if (type != TrackLists.ListType.Normal)
-                                    index++;
-                            }
-                            else if (option == "fails" && track.TrackState == Track.State.Downloaded && index < lines.Count && lines[index].StartsWith($"# Failed: {track}"))
-                            {
-                                lines[index] = "";
-                                needUpdate = true;
-                            }
-
-                            if (type == TrackLists.ListType.Normal)
-                                index++;
-                        }
-                    }
-                }
-            }
-
-            if (needUpdate)
-            {
-                if (!File.Exists(path))
-                    Directory.CreateDirectory(Path.GetDirectoryName(path));
-                File.WriteAllText(path, string.Join("\n", lines).TrimEnd('\n') + "\n");
-            }
-        }
-    }
-
-    public string TrackToLine(Track track, string failureReason="")
-    {
-        if (failureReason != "")
-            return $"# Failed: {track} [{failureReason}]";
-        if (track.DownloadPath != "")
-            return Path.GetRelativePath(Path.GetDirectoryName(path), track.DownloadPath).Replace("\\", "/");
-        return $"# {track}";
-    }
-
-    public bool HasFail(Track track, out string? reason)
-    {
-        reason = null;
-        var key = track.ToString().Trim();
-        if (key == "")
-            return false;
-        return fails.TryGetValue(key, out reason);
-    }
-
-    public string ReadAllText()
-    {
-        if (!File.Exists(path))
-            return "";
-        using var fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-        using var streamReader = new StreamReader(fileStream);
-        return streamReader.ReadToEnd();
-    }
-
-    public string[] ReadAllLines()
-    {
-        return ReadAllText().Split('\n');
-    }
-}
-
-
-class RateLimitedSemaphore
-{
-    private readonly int maxCount;
-    private readonly TimeSpan resetTimeSpan;
-    private readonly SemaphoreSlim semaphore;
-    private long nextResetTimeTicks;
-    private readonly object resetTimeLock = new object();
-
-    public RateLimitedSemaphore(int maxCount, TimeSpan resetTimeSpan)
-    {
-        this.maxCount = maxCount;
-        this.resetTimeSpan = resetTimeSpan;
-        this.semaphore = new SemaphoreSlim(maxCount, maxCount);
-        this.nextResetTimeTicks = (DateTimeOffset.UtcNow + this.resetTimeSpan).UtcTicks;
-    }
-
-    private void TryResetSemaphore()
-    {
-        if (!(DateTimeOffset.UtcNow.UtcTicks > Interlocked.Read(ref this.nextResetTimeTicks)))
-            return;
-
-        lock (this.resetTimeLock)
-        {
-            var currentTime = DateTimeOffset.UtcNow;
-            if (currentTime.UtcTicks > Interlocked.Read(ref this.nextResetTimeTicks))
-            {
-                int releaseCount = this.maxCount - this.semaphore.CurrentCount;
-                if (releaseCount > 0)
-                    this.semaphore.Release(releaseCount);
-
-                var newResetTimeTicks = (currentTime + this.resetTimeSpan).UtcTicks;
-                Interlocked.Exchange(ref this.nextResetTimeTicks, newResetTimeTicks);
-            }
-        }
-    }
-
-    public async Task WaitAsync()
-    {
-        TryResetSemaphore();
-        var semaphoreTask = this.semaphore.WaitAsync();
-
-        while (!semaphoreTask.IsCompleted)
-        {
-            var ticks = Interlocked.Read(ref this.nextResetTimeTicks);
-            var nextResetTime = new DateTimeOffset(new DateTime(ticks, DateTimeKind.Utc));
-            var delayTime = nextResetTime - DateTimeOffset.UtcNow;
-            var delayTask = delayTime >= TimeSpan.Zero ? Task.Delay(delayTime) : Task.CompletedTask;
-
-            await Task.WhenAny(semaphoreTask, delayTask);
-            TryResetSemaphore();
-        }
-    }
-}
-
diff --git a/slsk-batchdl/SearchAndDownload.cs b/slsk-batchdl/SearchAndDownload.cs
new file mode 100644
index 0000000..6dcddf1
--- /dev/null
+++ b/slsk-batchdl/SearchAndDownload.cs
@@ -0,0 +1,1338 @@
+using Soulseek;
+using System.Collections.Concurrent;
+using System.Text.RegularExpressions;
+
+using Data;
+using Enums;
+
+using File = System.IO.File;
+using Directory = System.IO.Directory;
+using ProgressBar = Konsole.ProgressBar;
+using SearchResponse = Soulseek.SearchResponse;
+using SlResponse = Soulseek.SearchResponse;
+using SlFile = Soulseek.File;
+using SlDictionary = System.Collections.Concurrent.ConcurrentDictionary<string, (Soulseek.SearchResponse, Soulseek.File)>;
+
+
+static partial class Program
+{
+    static async Task<string> SearchAndDownload(Track track, ResponseData? responseData = null)
+    {
+        if (Config.DoNotDownload)
+            throw new Exception();
+
+        responseData ??= new ResponseData();
+        var progress = GetProgressBar(Config.displayMode);
+        var results = new SlDictionary();
+        var fsResults = new SlDictionary();
+        var cts = new CancellationTokenSource();
+        var saveFilePath = "";
+        Task? downloadTask = null;
+        var fsDownloadLock = new object();
+        int fsResultsStarted = 0;
+        int downloading = 0;
+        bool notFound = false;
+        bool searchEnded = false;
+        string fsUser = "";
+        string fsFile = "";
+
+        if (track.Downloads != null)
+        {
+            results = track.Downloads;
+            goto downloads;
+        }
+
+        RefreshOrPrint(progress, 0, $"Waiting: {track}", false);
+
+        string searchText = $"{track.Artist} {track.Title}".Trim();
+        var removeChars = new string[] { " ", "_", "-" };
+
+        searches.TryAdd(track, new SearchInfo(results, progress));
+
+        void fastSearchDownload()
+        {
+            lock (fsDownloadLock)
+            {
+                if (downloading == 0 && !searchEnded)
+                {
+                    downloading = 1;
+                    var (r, f) = fsResults.MaxBy(x => x.Value.Item1.UploadSpeed).Value;
+                    saveFilePath = GetSavePath(f.Filename);
+                    fsUser = r.Username;
+                    fsFile = f.Filename;
+                    downloadTask = DownloadFile(r, f, saveFilePath, track, progress, cts);
+                }
+            }
+        }
+
+        void responseHandler(SearchResponse r)
+        {
+            if (r.Files.Count > 0)
+            {
+                responseData.lockedFilesCount += r.LockedFileCount;
+
+                foreach (var file in r.Files)
+                    results.TryAdd(r.Username + '\\' + file.Filename, (r, file));
+
+                if (Config.fastSearch && userSuccessCount.GetValueOrDefault(r.Username, 0) > Config.downrankOn)
+                {
+                    var f = r.Files.First();
+
+                    if (r.HasFreeUploadSlot && r.UploadSpeed / 1024.0 / 1024.0 >= Config.fastSearchMinUpSpeed
+                        && FileConditions.BracketCheck(track, InferTrack(f.Filename, track)) && Config.preferredCond.FileSatisfies(f, track, r))
+                    {
+                        fsResults.TryAdd(r.Username + '\\' + f.Filename, (r, f));
+                        if (Interlocked.Exchange(ref fsResultsStarted, 1) == 0)
+                        {
+                            Task.Delay(Config.fastSearchDelay).ContinueWith(tt => fastSearchDownload());
+                        }
+                    }
+                }
+            }
+        }
+
+        SearchOptions getSearchOptions(int timeout, FileConditions necCond, FileConditions prfCond)
+        {
+            return new SearchOptions(
+                minimumResponseFileCount: 1,
+                minimumPeerUploadSpeed: 1,
+                searchTimeout: Config.searchTimeout,
+                removeSingleCharacterSearchTerms: Config.removeSingleCharacterSearchTerms,
+                responseFilter: (response) =>
+                {
+                    return response.UploadSpeed > 0 && necCond.BannedUsersSatisfies(response);
+                },
+                fileFilter: (file) =>
+                {
+                    return Utils.IsMusicFile(file.Filename) && necCond.FileSatisfies(file, track, null);
+                });
+        }
+
+        void onSearch() => RefreshOrPrint(progress, 0, $"Searching: {track}", true);
+        await RunSearches(track, results, getSearchOptions, responseHandler, cts.Token, onSearch);
+
+        searches.TryRemove(track, out _);
+        searchEnded = true;
+        lock (fsDownloadLock) { }
+
+        if (downloading == 0 && results.IsEmpty && !Config.useYtdlp)
+        {
+            notFound = true;
+        }
+        else if (downloading == 1)
+        {
+            try
+            {
+                if (downloadTask == null || downloadTask.IsFaulted || downloadTask.IsCanceled)
+                    throw new TaskCanceledException();
+                await downloadTask;
+                userSuccessCount.AddOrUpdate(fsUser, 1, (k, v) => v + 1);
+            }
+            catch
+            {
+                saveFilePath = "";
+                downloading = 0;
+                results.TryRemove(fsUser + "\\" + fsFile, out _);
+                userSuccessCount.AddOrUpdate(fsUser, -1, (k, v) => v - 1);
+            }
+        }
+
+        cts.Dispose();
+
+    downloads:
+
+        if (downloading == 0 && !results.IsEmpty)
+        {
+            var orderedResults = OrderedResults(results, track, true);
+
+            int trackTries = Config.maxRetriesPerTrack;
+            async Task<bool> process(SlResponse response, SlFile file)
+            {
+                saveFilePath = GetSavePath(file.Filename);
+                try
+                {
+                    downloading = 1;
+                    await DownloadFile(response, file, saveFilePath, track, progress);
+                    userSuccessCount.AddOrUpdate(response.Username, 1, (k, v) => v + 1);
+                    return true;
+                }
+                catch (Exception e)
+                {
+                    downloading = 0;
+                    if (!IsConnectedAndLoggedIn())
+                        throw;
+                    userSuccessCount.AddOrUpdate(response.Username, -1, (k, v) => v - 1);
+                    if (--trackTries <= 0)
+                    {
+                        RefreshOrPrint(progress, 0, $"Out of download retries: {track}", true);
+                        WriteLine("Last error was: " + e.Message, ConsoleColor.DarkYellow, true);
+                        throw new SearchAndDownloadException(FailureReason.OutOfDownloadRetries);
+                    }
+                    return false;
+                }
+            }
+
+            // the first result is usually fine, no need to sort the entire sequence
+            var fr = orderedResults.First();
+            bool success = await process(fr.response, fr.file);
+
+            if (!success)
+            {
+                fr = orderedResults.Skip(1).FirstOrDefault();
+                if (fr != default)
+                {
+                    if (userSuccessCount.GetValueOrDefault(fr.response.Username, 0) > Config.ignoreOn)
+                    {
+                        success = await process(fr.response, fr.file);
+                    }
+                    if (!success)
+                    {
+                        foreach (var (response, file) in orderedResults.Skip(2))
+                        {
+                            if (userSuccessCount.GetValueOrDefault(response.Username, 0) <= Config.ignoreOn)
+                                continue;
+                            success = await process(response, file);
+                            if (success) break;
+                        }
+                    }
+                }
+            }
+        }
+
+        if (downloading == 0 && Config.useYtdlp)
+        {
+            notFound = false;
+            try
+            {
+                RefreshOrPrint(progress, 0, $"yt-dlp search: {track}", true);
+                var ytResults = await Extractors.YouTube.YtdlpSearch(track);
+
+                if (ytResults.Count > 0)
+                {
+                    foreach (var (length, id, title) in ytResults)
+                    {
+                        if (Config.necessaryCond.LengthToleranceSatisfies(length, track.Length))
+                        {
+                            string saveFilePathNoExt = GetSavePathNoExt(title);
+                            downloading = 1;
+                            RefreshOrPrint(progress, 0, $"yt-dlp download: {track}", true);
+                            saveFilePath = await Extractors.YouTube.YtdlpDownload(id, saveFilePathNoExt, Config.ytdlpArgument);
+                            RefreshOrPrint(progress, 100, $"Succeded: yt-dlp completed download for {track}", true);
+                            break;
+                        }
+                    }
+                }
+            }
+            catch (Exception e)
+            {
+                saveFilePath = "";
+                downloading = 0;
+                RefreshOrPrint(progress, 0, $"{e.Message}", true);
+                throw new SearchAndDownloadException(FailureReason.NoSuitableFileFound);
+            }
+        }
+
+        if (downloading == 0)
+        {
+            if (notFound)
+            {
+                string lockedFilesStr = responseData.lockedFilesCount > 0 ? $" (Found {responseData.lockedFilesCount} locked files)" : "";
+                RefreshOrPrint(progress, 0, $"Not found: {track}{lockedFilesStr}", true);
+                throw new SearchAndDownloadException(FailureReason.NoSuitableFileFound);
+            }
+            else
+            {
+                RefreshOrPrint(progress, 0, $"All downloads failed: {track}", true);
+                throw new SearchAndDownloadException(FailureReason.AllDownloadsFailed);
+            }
+        }
+
+        if (Config.nameFormat.Length > 0)
+            saveFilePath = ApplyNamingFormat(saveFilePath, track);
+
+        return Path.GetFullPath(saveFilePath);
+    }
+
+
+    static async Task<List<List<Track>>> GetAlbumDownloads(Track track, ResponseData responseData)
+    {
+        var results = new ConcurrentDictionary<string, (SearchResponse, Soulseek.File)>();
+        SearchOptions getSearchOptions(int timeout, FileConditions nec, FileConditions prf) =>
+            new SearchOptions(
+                minimumResponseFileCount: 1,
+                minimumPeerUploadSpeed: 1,
+                removeSingleCharacterSearchTerms: Config.removeSingleCharacterSearchTerms,
+                searchTimeout: timeout,
+                responseFilter: (response) =>
+                {
+                    return response.UploadSpeed > 0 && nec.BannedUsersSatisfies(response);
+                }
+            );
+        void handler(SlResponse r)
+        {
+            responseData.lockedFilesCount += r.LockedFileCount;
+
+            if (r.Files.Count > 0)
+            {
+                foreach (var file in r.Files)
+                    results.TryAdd(r.Username + "\\" + file.Filename, (r, file));
+            }
+        }
+        var cts = new CancellationTokenSource();
+
+        await RunSearches(track, results, getSearchOptions, handler, cts.Token);
+
+        string fullPath((SearchResponse r, Soulseek.File f) x) { return x.r.Username + "\\" + x.f.Filename; }
+
+        var orderedResults = OrderedResults(results, track, false, false, albumMode: true);
+
+        var discPattern = new Regex(@"^(?i)(dis[c|k]|cd)\s*\d{1,2}$");
+        bool canMatchDiscPattern = !discPattern.IsMatch(track.Album) && !discPattern.IsMatch(track.Artist);
+        var directoryStructure = new Dictionary<string, List<(SlResponse response, SlFile file)>>();
+
+        foreach (var x in orderedResults)
+        {
+            var path = fullPath(x);
+            var dirpath = path[..path.LastIndexOf('\\')];
+
+            if (!directoryStructure.ContainsKey(dirpath))
+            {
+                directoryStructure[dirpath] = new() { x };
+            }
+            else
+            {
+                directoryStructure[dirpath].Add(x);
+            }
+        }
+
+        if (canMatchDiscPattern)
+        {
+            foreach (var key in directoryStructure.Keys.ToArray())
+            {
+                var dirname = key[(key.LastIndexOf('\\') + 1)..];
+            
+                if (discPattern.IsMatch(dirname))
+                {
+                    directoryStructure.Remove(key, out var val);
+                    var newKey = key[..key.LastIndexOf('\\')];
+
+                    if (directoryStructure.ContainsKey(newKey))
+                    {
+                        directoryStructure[newKey].AddRange(val);
+                    }
+                    else
+                    {
+                        directoryStructure[newKey] = val;
+                    }
+                }
+            }
+        }
+
+        foreach ((var key, var val) in directoryStructure)
+        {
+            foreach ((var key2, var val2) in directoryStructure)
+            {
+                if (key == key2)
+                    continue;
+
+                if ((key2 + '\\').StartsWith(key + '\\'))
+                {
+                    val.AddRange(val2);
+                    directoryStructure.Remove(key2);
+                }
+            }
+        }
+
+        int min, max;
+        if (Config.minAlbumTrackCount > -1 || Config.maxAlbumTrackCount > -1)
+        {
+            min = Config.minAlbumTrackCount;
+            max = Config.maxAlbumTrackCount;
+        }
+        else
+        {
+            min = track.MinAlbumTrackCount;
+            max = track.MaxAlbumTrackCount;
+        }
+
+        bool countIsGood(int count) => count >= min && (max == -1 || count <= max);
+
+        var result = new List<List<Track>>();
+
+        foreach ((var key, var val) in directoryStructure)
+        {
+            int musicFileCount = val.Count(x => Utils.IsMusicFile(x.file.Filename));
+
+            if (!countIsGood(musicFileCount))
+                continue;
+
+            var ls = new List<Track>();
+
+            foreach (var x in val)
+            {
+                var t = new Track
+                {
+                    Artist = track.Artist,
+                    Album = track.Album,
+                    Length = x.file.Length ?? -1,
+                    IsNotAudio = !Utils.IsMusicFile(x.file.Filename),
+                    Downloads = new ConcurrentDictionary<string, (SlResponse, SlFile file)>(
+                    new Dictionary<string, (SlResponse response, SlFile file)> { { x.response.Username + '\\' + x.file.Filename, x } })
+                };
+                ls.Add(t);
+            }
+
+            ls = ls.OrderBy(t => t.IsNotAudio).ThenBy(t => t.Downloads.First().Value.Item2.Filename).ToList();
+
+            result.Add(ls);
+        }
+
+        if (result.Count == 0)
+            result.Add(new List<Track>());
+
+        return result;
+    }
+
+
+    static async Task<List<Track>> GetAggregateTracks(Track track, ResponseData responseData)
+    {
+        var results = new ConcurrentDictionary<string, (SearchResponse, Soulseek.File)>();
+        SearchOptions getSearchOptions(int timeout, FileConditions nec, FileConditions prf) =>
+            new SearchOptions(
+                minimumResponseFileCount: 1,
+                minimumPeerUploadSpeed: 1,
+                removeSingleCharacterSearchTerms: Config.removeSingleCharacterSearchTerms,
+                searchTimeout: timeout,
+                responseFilter: (response) =>
+                {
+                    return response.UploadSpeed > 0 && nec.BannedUsersSatisfies(response);
+                },
+                fileFilter: (file) =>
+                {
+                    return Utils.IsMusicFile(file.Filename) && nec.FileSatisfies(file, track, null);
+                    //&& FileConditions.StrictString(file.Filename, track.ArtistName, ignoreCase: true)
+                    //&& FileConditions.StrictString(file.Filename, track.TrackTitle, ignoreCase: true)
+                    //&& FileConditions.StrictString(file.Filename, track.Album, ignoreCase: true);
+                }
+            );
+        void handler(SlResponse r)
+        {
+            responseData.lockedFilesCount += r.LockedFileCount;
+
+            if (r.Files.Count > 0)
+            {
+                foreach (var file in r.Files)
+                    results.TryAdd(r.Username + "\\" + file.Filename, (r, file));
+            }
+        }
+        var cts = new CancellationTokenSource();
+
+        await RunSearches(track, results, getSearchOptions, handler, cts.Token);
+
+        string artistName = track.Artist.Trim();
+        string trackName = track.Title.Trim();
+        string albumName = track.Album.Trim();
+
+        var fileResponses = results.Select(x => x.Value);
+
+        var equivalentFiles = EquivalentFiles(track, fileResponses).ToList();
+
+        if (!Config.relax)
+        {
+            equivalentFiles = equivalentFiles
+                .Where(x => FileConditions.StrictString(x.Item1.Title, track.Title, ignoreCase: true)
+                        && (FileConditions.StrictString(x.Item1.Artist, track.Artist, ignoreCase: true, boundarySkipWs: false)
+                            || FileConditions.StrictString(x.Item1.Title, track.Artist, ignoreCase: true, boundarySkipWs: false)
+                                && x.Item1.Title.ContainsInBrackets(track.Artist, ignoreCase: true)))
+                .ToList();
+        }
+
+        var tracks = equivalentFiles
+            .Select(kvp =>
+            {
+                kvp.Item1.Downloads = new SlDictionary(
+                    kvp.Item2.ToDictionary(item => { return item.response.Username + "\\" + item.file.Filename; }, item => item));
+                return kvp.Item1;
+            }).ToList();
+
+        return tracks;
+    }
+
+
+    static async Task<List<List<List<Track>>>> GetAggregateAlbums(Track track, ResponseData responseData)
+    {
+        int maxDiff = Config.necessaryCond.LengthTolerance;
+
+        if (maxDiff < 0)
+            maxDiff = 3;
+
+        bool lengthsAreSimilar(int[] sorted1, int[] sorted2)
+        {
+            if (sorted1.Length != sorted2.Length)
+                return false;
+
+            for (int i = 0; i < sorted1.Length; i++)
+            {
+                if (Math.Abs(sorted1[i] - sorted2[i]) > maxDiff)
+                    return false;
+            }
+
+            return true;
+        }
+
+        var albums = await GetAlbumDownloads(track, responseData);
+
+        var sortedLengthLists = new List<(int[] lengths, List<Track> album)>();
+
+        foreach (var album in albums)
+        {
+            var sortedLengths = album.Where(x => !x.IsNotAudio).Select(x => x.Length).OrderBy(x => x).ToArray();
+            sortedLengthLists.Add((sortedLengths, album));
+        }
+
+        var lengthsList = new List<int[]>();
+        var res = new List<List<List<Track>>>();
+
+        foreach ((var lengths, var album) in sortedLengthLists)
+        {
+            bool found = false;
+
+            for (int i = 0; i < lengthsList.Count; i++)
+            {
+                if (lengthsAreSimilar(lengths, lengthsList[i]))
+                {
+                    if (lengths.Length == 1 && lengthsList[i].Length == 1) 
+                    {
+                        var t1 = InferTrack(album[0].Downloads.First().Value.Item2.Filename, new Track());
+                        var t2 = InferTrack(res[i][0][0].Downloads.First().Value.Item2.Filename, new Track());
+
+                        if ((t2.Artist.ContainsIgnoreCase(t1.Artist) || t1.Artist.ContainsIgnoreCase(t2.Artist))
+                            && (t2.Title.ContainsIgnoreCase(t1.Title) || t1.Title.ContainsIgnoreCase(t2.Title)))
+                        {
+                            found = true;
+                        }
+                    }
+                    else
+                    {
+                        found = true;
+                    }
+                    
+                    if (found)
+                    {
+                        res[i].Add(album);
+                        break;
+                    }
+                }
+            }
+
+            if (found)
+            {
+                continue;
+            }
+            else
+            {
+                lengthsList.Add(lengths);
+                res.Add(new List<List<Track>> { album });
+            }
+        }
+
+        res = res.Where(x => x.Count >= Config.minUsersAggregate).OrderByDescending(x => x.Count).ToList();
+
+        return res; // Note: The nested lists are still ordered according to OrderedResults
+    }
+
+
+    static async Task<List<(string dir, SlFile file)>> GetAllFilesInFolder(string user, string folderPrefix)
+    {
+        var browseOptions = new BrowseOptions();
+        var res = new List<(string dir, SlFile file)>();
+
+        folderPrefix = folderPrefix.TrimEnd('\\') + '\\';
+        var userFileList = await client.BrowseAsync(user, browseOptions);
+
+        foreach (var dir in userFileList.Directories)
+        {
+            string dirname = dir.Name.TrimEnd('\\') + '\\';
+            if (dirname.StartsWith(folderPrefix))
+            {
+                res.AddRange(dir.Files.Select(x => (dir.Name, x)));
+            }
+        }
+        return res;
+
+        // It would be much better to use GetDirectoryContentsAsync. Unfortunately it only returns the file
+        // names without full paths, and DownloadAsync needs full paths in order to download files.
+        // Therefore it would not be possible to download any files that are in a subdirectory of the folder.
+
+        // var dir = await client.GetDirectoryContentsAsync(user, folderPrefix);
+        // var res = dir.Files.Select(x => (folderPrefix, x)).ToList();
+        // return res;
+    }
+
+
+    static async Task CompleteFolder(List<Track> tracks, SearchResponse response, string folder)
+    {
+        try
+        {
+            var allFiles = await GetAllFilesInFolder(response.Username, folder);
+
+            if (allFiles.Count > tracks.Count)
+            {
+                var paths = tracks.Select(x => x.Downloads.First().Value.Item2.Filename).ToHashSet();
+                var first = tracks[0];
+
+                foreach ((var dir, var file) in allFiles)
+                {
+                    var fullPath = dir + '\\' + file.Filename;
+                    if (!paths.Contains(fullPath))
+                    {
+                        var newFile = new SlFile(file.Code, fullPath, file.Size, file.Extension, file.Attributes);
+                        var t = new Track
+                        {
+                            Artist = first.Artist,
+                            Album = first.Album,
+                            IsNotAudio = !Utils.IsMusicFile(file.Filename),
+                            Downloads = new ConcurrentDictionary<string, (SlResponse, SlFile file)>(
+                                new Dictionary<string, (SlResponse response, SlFile file)> { { response.Username + '\\' + fullPath, (response, newFile) } })
+                        };
+                        tracks.Add(t);
+                    }
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            WriteLine($"Error getting complete list of files: {ex}", ConsoleColor.DarkYellow);
+        }
+    }
+
+
+    static IOrderedEnumerable<(Track, IEnumerable<(SlResponse response, SlFile file)>)> EquivalentFiles(Track track,
+        IEnumerable<(SlResponse, SlFile)> fileResponses, int minShares = -1)
+    {
+        if (minShares == -1)
+            minShares = Config.minUsersAggregate;
+
+        Track inferTrack((SearchResponse r, Soulseek.File f) x)
+        {
+            var t = InferTrack(x.f.Filename, track);
+            t.Length = x.f.Length ?? -1;
+            return t;
+        }
+
+        var res = fileResponses
+            .GroupBy(inferTrack, new TrackStringComparer(ignoreCase: true))
+            .Where(group => group.Select(x => x.Item1.Username).Distinct().Count() >= minShares)
+            .SelectMany(group =>
+            {
+                var sortedTracks = group.OrderBy(t => t.Item2.Length).Where(x => x.Item2.Length != null).ToList();
+                var groups = new List<(Track, List<(SearchResponse, Soulseek.File)>)>();
+                var noLengthGroup = group.Where(x => x.Item2.Length == null);
+                for (int i = 0; i < sortedTracks.Count;)
+                {
+                    var subGroup = new List<(SearchResponse, Soulseek.File)> { sortedTracks[i] };
+                    int j = i + 1;
+                    while (j < sortedTracks.Count)
+                    {
+                        int l1 = (int)sortedTracks[j].Item2.Length;
+                        int l2 = (int)sortedTracks[i].Item2.Length;
+                        if (Config.necessaryCond.LengthTolerance == -1 || Math.Abs(l1 - l2) <= Config.necessaryCond.LengthTolerance)
+                        {
+                            subGroup.Add(sortedTracks[j]);
+                            j++;
+                        }
+                        else break;
+                    }
+                    var t = new Track(group.Key);
+                    t.Length = (int)sortedTracks[i].Item2.Length;
+                    groups.Add((t, subGroup));
+                    i = j;
+                }
+
+                if (noLengthGroup.Any())
+                {
+                    if (groups.Count > 0 && !Config.preferredCond.AcceptNoLength)
+                        groups.First().Item2.AddRange(noLengthGroup);
+                    else
+                        groups.Add((group.Key, noLengthGroup.ToList()));
+                }
+
+                return groups.Where(subGroup => subGroup.Item2.Select(x => x.Item1.Username).Distinct().Count() >= minShares)
+                    .Select(subGroup => (subGroup.Item1, subGroup.Item2.AsEnumerable()));
+            }).OrderByDescending(x => x.Item2.Count());
+
+        return res;
+    }
+
+
+    static IOrderedEnumerable<(SlResponse response, SlFile file)> OrderedResults(IEnumerable<KeyValuePair<string, (SlResponse, SlFile)>> results,
+        Track track, bool useInfer = false, bool useLevenshtein = true, bool albumMode = false)
+    {
+        bool useBracketCheck = true;
+        if (albumMode)
+        {
+            useBracketCheck = false;
+            useLevenshtein = false;
+            useInfer = false;
+        }
+
+        Dictionary<string, (Track, int)>? infTracksAndCounts = null;
+        if (useInfer)
+        {
+            var equivalentFiles = EquivalentFiles(track, results.Select(x => x.Value), 1);
+            infTracksAndCounts = equivalentFiles
+                .SelectMany(t => t.Item2, (t, f) => new { t.Item1, f.response.Username, f.file.Filename, Count = t.Item2.Count() })
+                .ToSafeDictionary(x => $"{x.Username}\\{x.Filename}", y => (y.Item1, y.Count));
+        }
+
+        (Track, int) inferredTrack((SearchResponse response, Soulseek.File file) x)
+        {
+            string key = $"{x.response.Username}\\{x.file.Filename}";
+            if (infTracksAndCounts != null && infTracksAndCounts.ContainsKey(key))
+                return infTracksAndCounts[key];
+            return (new Track(), 0);
+        }
+
+        int levenshtein((SearchResponse response, Soulseek.File file) x)
+        {
+            Track t = inferredTrack(x).Item1;
+            string t1 = track.Title.RemoveFt().ReplaceSpecialChars("").Replace(" ", "").Replace("_", "").ToLower();
+            string t2 = t.Title.RemoveFt().ReplaceSpecialChars("").Replace(" ", "").Replace("_", "").ToLower();
+            return Utils.Levenshtein(t1, t2);
+        }
+
+        var random = new Random();
+        return results.Select(kvp => (response: kvp.Value.Item1, file: kvp.Value.Item2))
+                .Where(x => userSuccessCount.GetValueOrDefault(x.response.Username, 0) > Config.ignoreOn)
+                .OrderByDescending(x => userSuccessCount.GetValueOrDefault(x.response.Username, 0) > Config.downrankOn)
+                .ThenByDescending(x => Config.necessaryCond.FileSatisfies(x.file, track, x.response))
+                .ThenByDescending(x => Config.preferredCond.BannedUsersSatisfies(x.response))
+                .ThenByDescending(x => (x.file.Length != null && x.file.Length > 0) || Config.preferredCond.AcceptNoLength)
+                .ThenByDescending(x => !useBracketCheck || FileConditions.BracketCheck(track, inferredTrack(x).Item1)) // downrank result if it contains '(' or '[' and the title does not (avoid remixes)
+                .ThenByDescending(x => Config.preferredCond.StrictTitleSatisfies(x.file.Filename, track.Title))
+                .ThenByDescending(x => Config.preferredCond.StrictArtistSatisfies(x.file.Filename, track.Title))
+                .ThenByDescending(x => Config.preferredCond.LengthToleranceSatisfies(x.file, track.Length))
+                .ThenByDescending(x => Config.preferredCond.FormatSatisfies(x.file.Filename))
+                .ThenByDescending(x => Config.preferredCond.StrictAlbumSatisfies(x.file.Filename, track.Album))
+                .ThenByDescending(x => Config.preferredCond.BitrateSatisfies(x.file))
+                .ThenByDescending(x => Config.preferredCond.SampleRateSatisfies(x.file))
+                .ThenByDescending(x => Config.preferredCond.BitDepthSatisfies(x.file))
+                .ThenByDescending(x => Config.preferredCond.FileSatisfies(x.file, track, x.response))
+                .ThenByDescending(x => x.response.HasFreeUploadSlot)
+                .ThenByDescending(x => x.response.UploadSpeed / 1024 / 650)
+                .ThenByDescending(x => albumMode || FileConditions.StrictString(x.file.Filename, track.Title))
+                .ThenByDescending(x => !albumMode || FileConditions.StrictString(Utils.GetDirectoryNameSlsk(x.file.Filename), track.Album))
+                .ThenByDescending(x => FileConditions.StrictString(x.file.Filename, track.Artist, boundarySkipWs: false))
+                .ThenByDescending(x => useInfer ? inferredTrack(x).Item2 : 0) // sorts by the number of occurences of this track
+                .ThenByDescending(x => x.response.UploadSpeed / 1024 / 350)
+                .ThenByDescending(x => (x.file.BitRate ?? 0) / 80)
+                .ThenByDescending(x => useLevenshtein ? levenshtein(x) / 5 : 0) // sorts by the distance between the track title and the inferred title of the search result
+                .ThenByDescending(x => random.Next());
+    }
+
+
+    static async Task RunSearches(Track track, SlDictionary results, Func<int, FileConditions, FileConditions, SearchOptions> getSearchOptions,
+        Action<SearchResponse> responseHandler, CancellationToken? ct = null, Action? onSearch = null)
+    {
+        bool artist = track.Artist.Length > 0;
+        bool title = track.Title.Length > 0;
+        bool album = track.Album.Length > 0;
+
+        string search = GetSearchString(track);
+        var searchTasks = new List<Task>();
+
+        var defaultSearchOpts = getSearchOptions(Config.searchTimeout, Config.necessaryCond, Config.preferredCond);
+        searchTasks.Add(Search(search, defaultSearchOpts, responseHandler, ct, onSearch));
+
+        if (search.RemoveDiacriticsIfExist(out string noDiacrSearch) && !track.ArtistMaybeWrong)
+        {
+            searchTasks.Add(Search(noDiacrSearch, defaultSearchOpts, responseHandler, ct, onSearch));
+        }
+
+        await Task.WhenAll(searchTasks);
+
+        if (results.IsEmpty && track.ArtistMaybeWrong && title)
+        {
+            var cond = new FileConditions(Config.necessaryCond);
+            var infTrack = InferTrack(track.Title, new Track());
+            cond.StrictTitle = infTrack.Title == track.Title;
+            cond.StrictArtist = false;
+            var opts = getSearchOptions(Math.Min(Config.searchTimeout, 5000), cond, Config.preferredCond);
+            searchTasks.Add(Search($"{infTrack.Artist} {infTrack.Title}", opts, responseHandler, ct, onSearch));
+        }
+
+        if (Config.desperateSearch)
+        {
+            await Task.WhenAll(searchTasks);
+
+            if (results.IsEmpty && !track.ArtistMaybeWrong)
+            {
+                if (artist && album && title)
+                {
+                    var cond = new FileConditions(Config.necessaryCond)
+                    {
+                        StrictTitle = true,
+                        StrictAlbum = true
+                    };
+                    var opts = getSearchOptions(Math.Min(Config.searchTimeout, 5000), cond, Config.preferredCond);
+                    searchTasks.Add(Search($"{track.Artist} {track.Album}", opts, responseHandler, ct, onSearch));
+                }
+                if (artist && title && track.Length != -1 && Config.necessaryCond.LengthTolerance != -1)
+                {
+                    var cond = new FileConditions(Config.necessaryCond)
+                    {
+                        LengthTolerance = -1,
+                        StrictTitle = true,
+                        StrictArtist = true
+                    };
+                    var opts = getSearchOptions(Math.Min(Config.searchTimeout, 5000), cond, Config.preferredCond);
+                    searchTasks.Add(Search($"{track.Artist} {track.Title}", opts, responseHandler, ct, onSearch));
+                }
+            }
+
+            await Task.WhenAll(searchTasks);
+
+            if (results.IsEmpty)
+            {
+                var track2 = track.ArtistMaybeWrong ? InferTrack(track.Title, new Track()) : track;
+
+                if (track.Album.Length > 3 && album)
+                {
+                    var cond = new FileConditions(Config.necessaryCond)
+                    {
+                        StrictAlbum = true,
+                        StrictTitle = !track.ArtistMaybeWrong,
+                        StrictArtist = !track.ArtistMaybeWrong,
+                        LengthTolerance = -1
+                    };
+                    var opts = getSearchOptions(Math.Min(Config.searchTimeout, 5000), cond, Config.preferredCond);
+                    searchTasks.Add(Search($"{track.Album}", opts, responseHandler, ct, onSearch));
+                }
+                if (track2.Title.Length > 3 && artist)
+                {
+                    var cond = new FileConditions(Config.necessaryCond)
+                    {
+                        StrictTitle = !track.ArtistMaybeWrong,
+                        StrictArtist = !track.ArtistMaybeWrong,
+                        LengthTolerance = -1
+                    };
+                    var opts = getSearchOptions(Math.Min(Config.searchTimeout, 5000), cond, Config.preferredCond);
+                    searchTasks.Add(Search($"{track2.Title}", opts, responseHandler, ct, onSearch));
+                }
+                if (track2.Artist.Length > 3 && title)
+                {
+                    var cond = new FileConditions(Config.necessaryCond)
+                    {
+                        StrictTitle = !track.ArtistMaybeWrong,
+                        StrictArtist = !track.ArtistMaybeWrong,
+                        LengthTolerance = -1
+                    };
+                    var opts = getSearchOptions(Math.Min(Config.searchTimeout, 5000), cond, Config.preferredCond);
+                    searchTasks.Add(Search($"{track2.Artist}", opts, responseHandler, ct, onSearch));
+                }
+            }
+        }
+
+        await Task.WhenAll(searchTasks);
+    }
+
+
+    static async Task Search(string search, SearchOptions opts, Action<SearchResponse> rHandler, CancellationToken? ct = null, Action? onSearch = null)
+    {
+        await searchSemaphore.WaitAsync();
+        try
+        {
+            search = CleanSearchString(search);
+            var q = SearchQuery.FromText(search);
+            onSearch?.Invoke();
+            await client.SearchAsync(q, options: opts, cancellationToken: ct, responseHandler: rHandler);
+        }
+        catch (OperationCanceledException) { }
+    }
+
+
+    static async Task SearchAndPrintResults(List<Track> tracks)
+    {
+        foreach (var track in tracks)
+        {
+            Console.WriteLine($"Results for {track}:");
+
+            SearchOptions getSearchOptions(int timeout, FileConditions necCond, FileConditions prfCond)
+            {
+                return new SearchOptions(
+                    minimumResponseFileCount: 1,
+                    minimumPeerUploadSpeed: 1,
+                    searchTimeout: Config.searchTimeout,
+                    removeSingleCharacterSearchTerms: Config.removeSingleCharacterSearchTerms,
+                    responseFilter: (response) =>
+                    {
+                        return response.UploadSpeed > 0 && necCond.BannedUsersSatisfies(response);
+                    },
+                    fileFilter: (file) =>
+                    {
+                        return Utils.IsMusicFile(file.Filename) && (necCond.FileSatisfies(file, track, null) || Config.PrintResultsFull);
+                    });
+            }
+
+            var results = new SlDictionary();
+
+            void responseHandler(SearchResponse r)
+            {
+                if (r.Files.Count > 0)
+                {
+                    foreach (var file in r.Files)
+                        results.TryAdd(r.Username + '\\' + file.Filename, (r, file));
+                }
+            }
+
+            await RunSearches(track, results, getSearchOptions, responseHandler);
+
+            if (Config.DoNotDownload && results.IsEmpty)
+            {
+                WriteLine($"No results", ConsoleColor.Yellow);
+            }
+            else
+            {
+                var orderedResults = OrderedResults(results, track, true);
+                int count = 0;
+                Console.WriteLine();
+                foreach (var (response, file) in orderedResults)
+                {
+                    Console.WriteLine(DisplayString(track, file, response,
+                        Config.PrintResultsFull ? Config.necessaryCond : null, Config.PrintResultsFull ? Config.preferredCond : null,
+                        fullpath: Config.PrintResultsFull, infoFirst: true, showSpeed: Config.PrintResultsFull));
+                    count += 1;
+                }
+                WriteLine($"Total: {count}\n", ConsoleColor.Yellow);
+            }
+
+            Console.WriteLine();
+        }
+    }
+
+
+    static string GetSearchString(Track track)
+    {
+        if (track.Title.Length > 0)
+            return (track.Artist + " " + track.Title).Trim();
+        else if (track.Album.Length > 0)
+            return (track.Artist + " " + track.Album).Trim();
+        return track.Artist.Trim();
+    }
+
+
+    static string CleanSearchString(string str)
+    {
+        string old;
+        if (!Config.noRemoveSpecialChars)
+        {
+            old = str;
+            str = str.ReplaceSpecialChars(" ").Trim().RemoveConsecutiveWs();
+            if (str.Length == 0) str = old;
+        }
+        foreach (var banned in bannedTerms)
+        {
+            string b1 = banned;
+            string b2 = banned.Replace(" ", "-");
+            string b3 = banned.Replace(" ", "_");
+            string b4 = banned.Replace(" ", "");
+            foreach (var s in new string[] { b1, b2, b3, b4 })
+                str = str.Replace(s, string.Concat("*", s.AsSpan(1)), StringComparison.OrdinalIgnoreCase);
+        }
+
+        return str.Trim();
+    }
+
+
+    static Track InferTrack(string filename, Track defaultTrack)
+    {
+        var t = new Track(defaultTrack);
+        filename = Utils.GetFileNameWithoutExtSlsk(filename).Replace(" — ", " - ").Replace('_', ' ').Trim().RemoveConsecutiveWs();
+
+        var trackNumStart = new Regex(@"^(?:(?:[0-9][-\.])?\d{2,3}[. -]|\b\d\.\s|\b\d\s-\s)(?=.+\S)");
+        //var trackNumMiddle = new Regex(@"\s+-\s+(\d{2,3})(?: -|\.|)\s+|\s+-(\d{2,3})-\s+");
+        var trackNumMiddle = new Regex(@"(?<= - )((\d-)?\d{2,3}|\d{2,3}\.?)\s+");
+        var trackNumMiddleAlt = new Regex(@"\s+-(\d{2,3})-\s+");
+
+        if (trackNumStart.IsMatch(filename))
+        {
+            filename = trackNumStart.Replace(filename, "", 1).Trim();
+            if (filename.StartsWith("- "))
+                filename = filename[2..].Trim();
+        }
+        else
+        {
+            var reg = trackNumMiddle.IsMatch(filename) ? trackNumMiddle : (trackNumMiddleAlt.IsMatch(filename) ? trackNumMiddleAlt : null);
+            if (reg != null && !reg.IsMatch(defaultTrack.ToString(noInfo: true)))
+            {
+                filename = reg.Replace(filename, "<<tracknum>>", 1).Trim();
+                filename = Regex.Replace(filename, @"-\s*<<tracknum>>\s*-", "-");
+                filename = filename.Replace("<<tracknum>>", "");
+            }
+        }
+
+        string aname = t.Artist.Trim();
+        string tname = t.Title.Trim();
+        string alname = t.Album.Trim();
+        string fname = filename;
+
+        fname = fname.Replace('—', '-').Replace('_', ' ').Replace('[', '(').Replace(']', ')').ReplaceInvalidChars("", true).RemoveConsecutiveWs().Trim();
+        tname = tname.Replace('—', '-').Replace('_', ' ').Replace('[', '(').Replace(']', ')').ReplaceInvalidChars("", true).RemoveFt().RemoveConsecutiveWs().Trim();
+        aname = aname.Replace('—', '-').Replace('_', ' ').Replace('[', '(').Replace(']', ')').ReplaceInvalidChars("", true).RemoveFt().RemoveConsecutiveWs().Trim();
+        alname = alname.Replace('—', '-').Replace('_', ' ').Replace('[', '(').Replace(']', ')').ReplaceInvalidChars("", true).RemoveFt().RemoveConsecutiveWs().Trim();
+
+        bool maybeRemix = aname.Length > 0 && Regex.IsMatch(fname, @$"\({Regex.Escape(aname)} .+\)", RegexOptions.IgnoreCase);
+        string[] parts = fname.Split(new string[] { " - " }, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+        string[] realParts = filename.Split(new string[] { " - " }, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+
+        if (parts.Length != realParts.Length)
+            realParts = parts;
+
+        if (parts.Length == 1)
+        {
+            if (maybeRemix)
+                t.ArtistMaybeWrong = true;
+            t.Title = parts[0];
+        }
+        else if (parts.Length == 2)
+        {
+            t.Artist = realParts[0];
+            t.Title = realParts[1];
+
+            if (!parts[0].ContainsIgnoreCase(aname) || !parts[1].ContainsIgnoreCase(tname))
+            {
+                t.ArtistMaybeWrong = true;
+            }
+        }
+        else if (parts.Length == 3)
+        {
+            bool hasTitle = tname.Length > 0 && parts[2].ContainsIgnoreCase(tname);
+            if (hasTitle)
+                t.Title = realParts[2];
+
+            int artistPos = -1;
+            if (aname.Length > 0)
+            {
+                if (parts[0].ContainsIgnoreCase(aname))
+                    artistPos = 0;
+                else if (parts[1].ContainsIgnoreCase(aname))
+                    artistPos = 1;
+                else
+                    t.ArtistMaybeWrong = true;
+            }
+            int albumPos = -1;
+            if (alname.Length > 0)
+            {
+                if (parts[0].ContainsIgnoreCase(alname))
+                    albumPos = 0;
+                else if (parts[1].ContainsIgnoreCase(alname))
+                    albumPos = 1;
+            }
+            if (artistPos >= 0 && artistPos == albumPos)
+            {
+                artistPos = 0;
+                albumPos = 1;
+            }
+            if (artistPos == -1 && maybeRemix)
+            {
+                t.ArtistMaybeWrong = true;
+                artistPos = 0;
+                albumPos = 1;
+            }
+            if (artistPos == -1 && albumPos == -1)
+            {
+                t.ArtistMaybeWrong = true;
+                t.Artist = realParts[0] + " - " + realParts[1];
+            }
+            else if (artistPos >= 0)
+            {
+                t.Artist = parts[artistPos];
+            }
+
+            t.Title = parts[2];
+        }
+        else
+        {
+            int artistPos = -1, titlePos = -1;
+
+            if (aname.Length > 0)
+            {
+                var s = parts.Select((p, i) => (p, i)).Where(x => x.p.ContainsIgnoreCase(aname));
+                if (s.Any())
+                {
+                    artistPos = s.MinBy(x => Math.Abs(x.p.Length - aname.Length)).i;
+                    if (artistPos != -1)
+                        t.Artist = parts[artistPos];
+                }
+            }
+            if (tname.Length > 0)
+            {
+                var ss = parts.Select((p, i) => (p, i)).Where(x => x.i != artistPos && x.p.ContainsIgnoreCase(tname));
+                if (ss.Any())
+                {
+                    titlePos = ss.MinBy(x => Math.Abs(x.p.Length - tname.Length)).i;
+                    if (titlePos != -1)
+                        t.Title = parts[titlePos];
+                }
+            }
+        }
+
+        if (t.Title.Length == 0)
+        {
+            t.Title = fname;
+            t.ArtistMaybeWrong = true;
+        }
+        else if (t.Artist.Length > 0 && !t.Title.ContainsIgnoreCase(defaultTrack.Title) && !t.Artist.ContainsIgnoreCase(defaultTrack.Artist))
+        {
+            string[] x = { t.Artist, t.Album, t.Title };
+
+            var perm = (0, 1, 2);
+            (int, int, int)[] permutations = { (0, 2, 1), (1, 0, 2), (1, 2, 0), (2, 0, 1), (2, 1, 0) };
+
+            foreach (var p in permutations)
+            {
+                if (x[p.Item1].ContainsIgnoreCase(defaultTrack.Artist) && x[p.Item3].ContainsIgnoreCase(defaultTrack.Title))
+                {
+                    perm = p;
+                    break;
+                }
+            }
+
+            t.Artist = x[perm.Item1];
+            t.Album = x[perm.Item2];
+            t.Title = x[perm.Item3];
+        }
+
+        t.Title = t.Title.RemoveFt();
+        t.Artist = t.Artist.RemoveFt();
+
+        return t;
+    }
+
+
+    static async Task DownloadFile(SearchResponse response, Soulseek.File file, string filePath, Track track, ProgressBar progress, CancellationTokenSource? searchCts = null)
+    {
+        if (Config.DoNotDownload)
+            throw new Exception();
+
+        await WaitForLogin();
+        Directory.CreateDirectory(Path.GetDirectoryName(filePath));
+        string origPath = filePath;
+        filePath += ".incomplete";
+
+        var transferOptions = new TransferOptions(
+            stateChanged: (state) =>
+            {
+                if (downloads.TryGetValue(file.Filename, out var x))
+                    x.transfer = state.Transfer;
+            },
+            progressUpdated: (progress) =>
+            {
+                if (downloads.TryGetValue(file.Filename, out var x))
+                    x.bytesTransferred = progress.PreviousBytesTransferred;
+            }
+        );
+
+        try
+        {
+            using var cts = new CancellationTokenSource();
+            using var outputStream = new FileStream(filePath, FileMode.Create);
+            var wrapper = new DownloadWrapper(origPath, response, file, track, cts, progress);
+            downloads.TryAdd(file.Filename, wrapper);
+
+            // Attempt to make it resume downloads after a network interruption.
+            // Does not work: The resumed download will be queued until it goes stale.
+            // The host (slskd) reports that "Another upload to {user} is already in progress"
+            // when attempting to resume. Must wait until timeout, which can take minutes.
+
+            int maxRetries = 3;
+            int retryCount = 0;
+            while (true)
+            {
+                try
+                {
+                    await client.DownloadAsync(response.Username, file.Filename,
+                        () => Task.FromResult((Stream)outputStream),
+                        file.Size, startOffset: outputStream.Position,
+                        options: transferOptions, cancellationToken: cts.Token);
+
+                    break;
+                }
+                catch (SoulseekClientException)
+                {
+                    retryCount++;
+
+                    if (retryCount >= maxRetries || IsConnectedAndLoggedIn())
+                        throw;
+
+                    await WaitForLogin();
+                }
+            }
+        }
+        catch
+        {
+            if (File.Exists(filePath))
+                try { File.Delete(filePath); } catch { }
+            downloads.TryRemove(file.Filename, out var d);
+            if (d != null)
+                lock (d) { d.UpdateText(); }
+            throw;
+        }
+
+        try { searchCts?.Cancel(); }
+        catch { }
+
+        try { Utils.Move(filePath, origPath); }
+        catch (IOException) { WriteLine($"Failed to rename .incomplete file", ConsoleColor.DarkYellow, true); }
+
+        downloads.TryRemove(file.Filename, out var x);
+        if (x != null)
+        {
+            lock (x)
+            {
+                x.success = true;
+                x.UpdateText();
+            }
+        }
+    }
+
+
+    public class SearchAndDownloadException : Exception
+    {
+        public FailureReason reason;
+        public SearchAndDownloadException(FailureReason reason, string text = "") : base(text) { this.reason = reason; }
+    }
+
+
+    class DownloadWrapper
+    {
+        public string savePath;
+        public string displayText = "";
+        public int downloadRotatingBarState = 0;
+        public Soulseek.File file;
+        public Transfer? transfer;
+        public SearchResponse response;
+        public ProgressBar progress;
+        public Track track;
+        public long bytesTransferred = 0;
+        public bool stalled = false;
+        public bool queued = false;
+        public bool success = false;
+        public CancellationTokenSource cts;
+        public DateTime startTime = DateTime.Now;
+        public DateTime lastChangeTime = DateTime.Now;
+
+        TransferStates? prevTransferState = null;
+        long prevBytesTransferred = 0;
+        bool updatedTextDownload = false;
+        bool updatedTextSuccess = false;
+        readonly char[] bars = { '|', '/', '—', '\\' };
+
+        public DownloadWrapper(string savePath, SearchResponse response, Soulseek.File file, Track track, CancellationTokenSource cts, ProgressBar progress)
+        {
+            this.savePath = savePath;
+            this.response = response;
+            this.file = file;
+            this.cts = cts;
+            this.track = track;
+            this.progress = progress;
+            this.displayText = DisplayString(track, file, response);
+
+            RefreshOrPrint(progress, 0, "Initialize: " + displayText, true);
+            RefreshOrPrint(progress, 0, displayText, false);
+        }
+
+        public void UpdateText()
+        {
+            downloadRotatingBarState++;
+            downloadRotatingBarState %= bars.Length;
+            float? percentage = bytesTransferred / (float)file.Size;
+            queued = (transfer?.State & TransferStates.Queued) != 0;
+            string bar;
+            string state;
+            bool downloading = false;
+
+            if (stalled)
+            {
+                state = "Stalled";
+                bar = "";
+            }
+            else if (transfer != null)
+            {
+                if (queued)
+                    state = "Queued";
+                else if ((transfer.State & TransferStates.Initializing) != 0)
+                    state = "Initialize";
+                else if ((transfer.State & TransferStates.Completed) != 0)
+                {
+                    var flag = transfer.State & (TransferStates.Succeeded | TransferStates.Cancelled 
+                        | TransferStates.TimedOut | TransferStates.Errored | TransferStates.Rejected 
+                        | TransferStates.Aborted);
+                    state = flag.ToString();
+
+                    if (flag == TransferStates.Succeeded)
+                        success = true;
+                }
+                else
+                {
+                    state = transfer.State.ToString();
+                    if ((transfer.State & TransferStates.InProgress) != 0)
+                        downloading = true;
+                }
+
+                bar = success ? "" : bars[downloadRotatingBarState] + " ";
+            }
+            else
+            {
+                state = "NullState";
+                bar = "";
+            }
+
+            string txt = $"{bar}{state}:".PadRight(14) + $" {displayText}";
+            bool needSimplePrintUpdate = (downloading && !updatedTextDownload) || (success && !updatedTextSuccess);
+            updatedTextDownload |= downloading;
+            updatedTextSuccess |= success;
+
+            Console.ResetColor();
+            RefreshOrPrint(progress, (int)((percentage ?? 0) * 100), txt, needSimplePrintUpdate, needSimplePrintUpdate);
+
+        }
+
+        public DateTime UpdateLastChangeTime(bool updateAllFromThisUser = true, bool forceChanged = false)
+        {
+            bool changed = prevTransferState != transfer?.State || prevBytesTransferred != bytesTransferred;
+            if (changed || forceChanged)
+            {
+                lastChangeTime = DateTime.Now;
+                stalled = false;
+                if (updateAllFromThisUser)
+                {
+                    foreach (var (_, dl) in downloads)
+                    {
+                        if (dl != this && dl.response.Username == response.Username)
+                            dl.UpdateLastChangeTime(updateAllFromThisUser: false, forceChanged: true);
+                    }
+                }
+            }
+            prevTransferState = transfer?.State;
+            prevBytesTransferred = bytesTransferred;
+            return lastChangeTime;
+        }
+    }
+
+
+    class SearchInfo
+    {
+        public ConcurrentDictionary<string, (SearchResponse, Soulseek.File)> results;
+        public ProgressBar progress;
+
+        public SearchInfo(ConcurrentDictionary<string, (SearchResponse, Soulseek.File)> results, ProgressBar progress)
+        {
+            this.results = results;
+            this.progress = progress;
+        }
+    }
+
+}
+
+
diff --git a/slsk-batchdl/Spotify.cs b/slsk-batchdl/Spotify.cs
deleted file mode 100644
index ec7b7df..0000000
--- a/slsk-batchdl/Spotify.cs
+++ /dev/null
@@ -1,220 +0,0 @@
-using SpotifyAPI.Web;
-using SpotifyAPI.Web.Auth;
-using Swan;
-
-public class Spotify
-{
-    private EmbedIOAuthServer _server;
-    private readonly string _clientId;
-    private readonly string _clientSecret;
-    private SpotifyClient? _client;
-    private bool loggedIn = false;
-
-    // default spotify credentials (base64-encoded to keep the bots away)
-    public const string encodedSpotifyId = "MWJmNDY5M1bLaH9WJiYjFhNGY0MWJjZWQ5YjJjMWNmZGJiZDI=";
-    public const string encodedSpotifySecret = "Y2JlM2QxYTE5MzJkNDQ2MmFiOGUy3shTuf4Y2JhY2M3ZDdjYWU=";
-    public bool UsedDefaultCredentials { get; private set; }
-
-    public Spotify(string clientId="", string clientSecret="")
-    {
-        _clientId = clientId;
-        _clientSecret = clientSecret;
-
-        if (_clientId == "" || _clientSecret == "")
-        {
-            _clientId = System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(encodedSpotifyId.Replace("1bLaH9", "")));
-            _clientSecret = System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(encodedSpotifySecret.Replace("3shTuf4", "")));
-            UsedDefaultCredentials = true;
-        }
-    }
-
-    public async Task Authorize(bool login = false, bool needModify = false)
-    {
-        _client = null;
-
-        if (!login)
-        {
-            var config = SpotifyClientConfig.CreateDefault();
-
-            var request = new ClientCredentialsRequest(_clientId, _clientSecret);
-            var response = await new OAuthClient(config).RequestToken(request);
-
-            _client = new SpotifyClient(config.WithToken(response.AccessToken));
-        }
-        else
-        {
-            Swan.Logging.Logger.NoLogging();
-            _server = new EmbedIOAuthServer(new Uri("http://localhost:48721/callback"), 48721);
-            await _server.Start();
-
-            _server.AuthorizationCodeReceived += OnAuthorizationCodeReceived;
-            _server.ErrorReceived += OnErrorReceived;
-
-            var scope = new List<string> { 
-                Scopes.UserLibraryRead, Scopes.PlaylistReadPrivate, Scopes.PlaylistReadCollaborative
-            };
-
-            if (needModify)
-            {
-                scope.Add(Scopes.PlaylistModifyPublic);
-                scope.Add(Scopes.PlaylistModifyPrivate);
-            }
-
-            var request = new LoginRequest(_server.BaseUri, _clientId, LoginRequest.ResponseType.Code) { Scope = scope };
-
-            BrowserUtil.Open(request.ToUri());
-
-            await IsClientReady();
-        }
-    }
-
-    private async Task OnAuthorizationCodeReceived(object sender, AuthorizationCodeResponse response)
-    {
-        await _server.Stop();
-
-        var config = SpotifyClientConfig.CreateDefault();
-        var tokenResponse = await new OAuthClient(config).RequestToken(
-            new AuthorizationCodeTokenRequest(
-                _clientId, _clientSecret, response.Code, new Uri("http://localhost:48721/callback")
-            )
-        );
-
-        _client = new SpotifyClient(tokenResponse.AccessToken);
-        loggedIn = true;
-    }
-
-    private async Task OnErrorReceived(object sender, string error, string state)
-    {
-        await _server.Stop();
-        throw new Exception($"Aborting authorization, error received: {error}");
-    }
-
-    public async Task<bool> IsClientReady()
-    {
-        while (_client == null)
-            await Task.Delay(1000);
-        return true;
-    }
-
-    public async Task<List<Track>> GetLikes(int max = int.MaxValue, int offset = 0)
-    {
-        if (!loggedIn)
-            throw new Exception("Can't get liked music as user is not logged in");
-
-        List<Track> res = new List<Track>();
-        int limit = Math.Min(max, 50);
-
-        while (true)
-        {
-            var tracks = await _client.Library.GetTracks(new LibraryTracksRequest { Limit = limit, Offset = offset });
-
-            foreach (var track in tracks.Items)
-            {
-                string[] artists = ((IEnumerable<object>)track.Track.ReadProperty("artists")).Select(a => (string)a.ReadProperty("name")).ToArray();
-                string artist = artists[0];
-                string name = (string)track.Track.ReadProperty("name");
-                string album = (string)track.Track.ReadProperty("album").ReadProperty("name");
-                int duration = (int)track.Track.ReadProperty("durationMs");
-                res.Add(new Track { Album = album, Artist = artist, Title = name, Length = duration / 1000 });
-            }
-
-            if (tracks.Items.Count < limit || res.Count >= max)
-                break;
-
-            offset += limit;
-            limit = Math.Min(max - res.Count, 50);
-        }
-
-        return res;
-    }
-
-    public async Task RemoveTrackFromPlaylist(string playlistId, string trackUri)
-    {
-        var item = new PlaylistRemoveItemsRequest.Item { Uri = trackUri };
-        var pr = new PlaylistRemoveItemsRequest();
-        pr.Tracks = new List<PlaylistRemoveItemsRequest.Item>() { item };
-        try { await _client.Playlists.RemoveItems(playlistId, pr); }
-        catch { }
-    }
-
-    public async Task<(string?, string?, List<Track>)> GetPlaylist(string url, int max = int.MaxValue, int offset = 0)
-    {
-        var playlistId = GetPlaylistIdFromUrl(url);
-        var p = await _client.Playlists.Get(playlistId);
-
-        List<Track> res = new List<Track>();
-        int limit = Math.Min(max, 100);
-
-        while (true)
-        {
-            var tracks = await _client.Playlists.GetItems(playlistId, new PlaylistGetItemsRequest { Limit = limit, Offset = offset });
-
-            foreach (var track in tracks.Items)
-            {
-                try
-                {
-                    string[] artists = ((IEnumerable<object>)track.Track.ReadProperty("artists")).Select(a => (string)a.ReadProperty("name")).ToArray();
-                    var t = new Track()
-                    {
-                        Artist = artists[0],
-                        Album = (string)track.Track.ReadProperty("album").ReadProperty("name"),
-                        Title = (string)track.Track.ReadProperty("name"),
-                        Length = (int)track.Track.ReadProperty("durationMs") / 1000,
-                        URI = (string)track.Track.ReadProperty("uri"),
-                    };
-                    res.Add(t);
-                }
-                catch
-                {
-                    continue;
-                }
-            }
-
-            if (tracks.Items.Count < limit || res.Count >= max)
-                break;
-
-            offset += limit;
-            limit = Math.Min(max - res.Count, 100);
-        }
-
-        return (p.Name, p.Id, res);
-    }
-
-    private string GetPlaylistIdFromUrl(string url)
-    {
-        var uri = new Uri(url);
-        var segments = uri.Segments;
-        return segments[segments.Length - 1].TrimEnd('/');
-    }
-
-    public async Task<(Track, List<Track>)> GetAlbum(string url)
-    {
-        var albumId = GetAlbumIdFromUrl(url);
-        var album = await _client.Albums.Get(albumId);
-
-        List<Track> tracks = new List<Track>();
-
-        foreach (var track in album.Tracks.Items)
-        {
-            var t = new Track()
-            {
-                Album = album.Name,
-                Artist = track.Artists.First().Name,
-                Title = track.Name,
-                Length = track.DurationMs / 1000,
-                URI = track.Uri,
-            };
-            tracks.Add(t);
-        }
-
-        return (new Track { Album = album.Name, Artist = album.Artists.First().Name, IsAlbum = true }, tracks);
-    }
-
-    private string GetAlbumIdFromUrl(string url)
-    {
-        var uri = new Uri(url);
-        var segments = uri.Segments;
-        return segments[segments.Length - 1].TrimEnd('/');
-    }
-
-}
diff --git a/slsk-batchdl/Utils.cs b/slsk-batchdl/Utils.cs
index 3ee90e3..172388f 100644
--- a/slsk-batchdl/Utils.cs
+++ b/slsk-batchdl/Utils.cs
@@ -1,14 +1,16 @@
 using System.Net;
+using System.Text;
 using System.Text.RegularExpressions;
+using Enums;
 
 public static class Utils
 {
-    public static string[] musicExtensions = new string[] { ".mp3", ".wav", ".flac", ".ogg", ".aac", ".wma", ".m4a", ".alac", ".ape", ".opus" };
-    public static string[] imageExtensions = new string[] { ".jpg", ".jpeg", ".png" };
-    
+    public static readonly string[] musicExtensions = new string[] { ".mp3", ".flac", ".ogg", ".m4a", ".opus", ".wav", ".aac", ".alac" };
+    public static readonly string[] imageExtensions = new string[] { ".jpg", ".png", ".jpeg" };
+
     public static bool IsMusicExtension(string extension)
     {
-        return musicExtensions.Contains(('.' + extension.TrimStart('.')).ToLower());
+        return musicExtensions.Contains(extension.ToLower());
     }
 
     public static bool IsMusicFile(string fileName)
@@ -16,11 +18,123 @@ public static class Utils
         return musicExtensions.Contains(Path.GetExtension(fileName).ToLower());
     }
 
+    public static bool IsImageExtension(string extension)
+    {
+        return imageExtensions.Contains(extension.ToLower());
+    }
+
     public static bool IsImageFile(string fileName)
     {
         return imageExtensions.Contains(Path.GetExtension(fileName).ToLower());
     }
 
+    public static bool IsInternetUrl(this string str)
+    {
+        str = str.TrimStart();
+        return str.StartsWith("http://", StringComparison.OrdinalIgnoreCase)
+            || str.StartsWith("https://", StringComparison.OrdinalIgnoreCase);
+    }
+
+    public static void WriteAllLines(string path, IEnumerable<string> lines, char separator)
+    {
+        using (var writer = new StreamWriter(path))
+        {
+            foreach (var line in lines)
+            {
+                writer.Write(line);
+                writer.Write(separator);
+            }
+        }
+    }
+
+    public static string GetAsPathSlsk(string fname)
+    {
+        return fname.Replace('\\', Path.DirectorySeparatorChar);
+    }
+
+    public static string GetFileNameSlsk(string fname)
+    {
+        fname = fname.Replace('\\', Path.DirectorySeparatorChar);
+        return Path.GetFileName(fname);
+    }
+
+    public static string GetBaseNameSlsk(string path)
+    {
+        path = path.Replace('\\', Path.DirectorySeparatorChar).TrimEnd(Path.DirectorySeparatorChar);
+        return Path.GetFileName(path);
+    }
+
+    public static string GetFileNameWithoutExtSlsk(string fname)
+    {
+        fname = fname.Replace('\\', Path.DirectorySeparatorChar);
+        return Path.GetFileNameWithoutExtension(fname);
+    }
+
+    public static string GetExtensionSlsk(string fname)
+    {
+        fname = fname.Replace('\\', Path.DirectorySeparatorChar);
+        return Path.GetExtension(fname);
+    }
+
+    public static string GetDirectoryNameSlsk(string fname)
+    {
+        fname = fname.Replace('\\', Path.DirectorySeparatorChar);
+        return Path.GetDirectoryName(fname);
+    }
+
+    public static string ExpandUser(string path)
+    {
+        if (string.IsNullOrEmpty(path))
+        {
+            return path;
+        }
+
+        if (path.StartsWith("~"))
+        {
+            string homeDirectory = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
+            return Path.Combine(homeDirectory, path.Substring(1).TrimStart('/').TrimStart('\\'));
+        }
+
+        return path;
+    }
+
+    public static List<string> FromCsv(string csvLine)
+    {
+        var items = new List<string>();
+        var currentItem = new StringBuilder();
+        bool inQuotes = false;
+
+        for (int i = 0; i < csvLine.Length; i++)
+        {
+            char c = csvLine[i];
+
+            if (c == '"' && (i == 0 || csvLine[i - 1] != '\\'))
+            {
+                if (inQuotes && i + 1 < csvLine.Length && csvLine[i + 1] == '"')
+                {
+                    currentItem.Append('"');
+                    i++;
+                }
+                else
+                {
+                    inQuotes = !inQuotes;
+                }
+            }
+            else if (c == ',' && !inQuotes)
+            {
+                items.Add(currentItem.ToString());
+                currentItem.Clear();
+            }
+            else
+            {
+                currentItem.Append(c);
+            }
+        }
+        items.Add(currentItem.ToString());
+
+        return items;
+    }
+
     public static decimal Normalize(this double value)
     {
         return ((decimal)value) / 1.000000000000000000000000000000000m;
@@ -60,9 +174,13 @@ public static class Utils
 
     public static string Replace(this string s, string[] separators, string newVal)
     {
-        string[] temp;
-        temp = s.Split(separators, StringSplitOptions.RemoveEmptyEntries);
-        return String.Join(newVal, temp);
+        if (s.Length == 0)
+            return s;
+
+        foreach (var sep in separators)
+            s = s.Replace(sep, newVal);
+
+        return s;
     }
 
     public static string UnHtmlString(this string s)
@@ -76,117 +194,233 @@ public static class Utils
         return s;
     }
 
-    public static string ReplaceInvalidChars(this string str, string replaceStr, bool windows = false, bool removeSlash = true, bool alwaysRemoveSlash = false)
+    public static string ReplaceInvalidChars(this string str, string replaceStr, bool windows = false, bool removeSlash = true)
     {
-        char[] invalidChars = Path.GetInvalidFileNameChars();
+        if (str.Length == 0)
+            return str;
+
+        char[] invalidChars;
+
         if (windows)
-            invalidChars = new char[] { ':', '|', '?', '>', '<', '*', '"', '/', '\\' };
-        if (!removeSlash && !alwaysRemoveSlash)
-            invalidChars = invalidChars.Where(c => c != '/' && c != '\\').ToArray();
-        if (alwaysRemoveSlash)
+            invalidChars = new char[] { ':', '|', '?', '>', '<', '*', '"' }; // forward- and backslash are always included
+        else
+            invalidChars = Path.GetInvalidFileNameChars();
+
+        if (removeSlash)
         {
-            var x = invalidChars.ToList();
-            x.AddRange(new char[] { '/', '\\' });
-            invalidChars = x.ToArray();
+            str = str.Replace("/", replaceStr);
+            str = str.Replace("\\", replaceStr);
         }
-        foreach (char c in invalidChars)
+
+        foreach (var c in invalidChars)
+        {
+            if (!removeSlash && (c == '/' || c == '\\'))
+                continue;
             str = str.Replace(c.ToString(), replaceStr);
+        }
+
+        return str;
+    }
+
+    public static string ReplaceInvalidChars(this string str, char replaceChar, bool windows = false, bool removeSlash = true)
+    {
+        if (str.Length == 0)
+            return str;
+
+        char[] invalidChars;
+
+        if (windows)
+            invalidChars = new char[] { ':', '|', '?', '>', '<', '*', '"' }; // forward- and backslash are always included
+        else
+            invalidChars = Path.GetInvalidFileNameChars();
+
+        if (removeSlash)
+        {
+            str = str.Replace('/', replaceChar);
+            str = str.Replace('\\', replaceChar);
+        }
+
+        foreach (var c in invalidChars)
+        {
+            if (!removeSlash && (c == '/' || c == '\\'))
+                continue;
+            str = str.Replace(c, replaceChar);
+        }
+
         return str;
     }
 
     public static string ReplaceSpecialChars(this string str, string replaceStr)
     {
+        if (str.Length == 0)
+            return str;
+
         string special = ";:'\"|?!<>*/\\[]{}()-–—&%^$#@+=`~_";
         foreach (char c in special)
             str = str.Replace(c.ToString(), replaceStr);
         return str;
     }
 
-    public static string RemoveFt(this string str, bool removeParentheses = true, bool onlyIfNonempty = true)
+    public static string RemoveFt(this string str, bool removeParentheses = true)
     {
-        string[] ftStrings = { "feat.", "ft." };
-        string orig = str;
+        if (str.Length == 0)
+            return str;
+
+        var ftStrings = new string[] { "feat.", "ft." };
+        var open = new char[] { '(', '[' };
+        var close = new char[] { ')', ']' };
+        bool changed = false;
+
         foreach (string ftStr in ftStrings)
         {
             int ftIndex = str.IndexOf(ftStr, StringComparison.OrdinalIgnoreCase);
 
             if (ftIndex != -1)
             {
-                if (removeParentheses)
+                changed = true;
+                if (removeParentheses && ftIndex > 0)
                 {
-                    int openingParenthesesIndex = str.LastIndexOf('(', ftIndex);
-                    int closingParenthesesIndex = str.IndexOf(')', ftIndex);
-                    int openingBracketIndex = str.LastIndexOf('[', ftIndex);
-                    int closingBracketIndex = str.IndexOf(']', ftIndex);
+                    bool any = false;
 
-                    if (openingParenthesesIndex != -1 && closingParenthesesIndex != -1)
-                        str = str.Remove(openingParenthesesIndex, closingParenthesesIndex - openingParenthesesIndex + 1);
-                    else if (openingBracketIndex != -1 && closingBracketIndex != -1)
-                        str = str.Remove(openingBracketIndex, closingBracketIndex - openingBracketIndex + 1);
-                    else
-                        str = str.Substring(0, ftIndex);
+                    for (int i = 0; i < 2; i++)
+                    {
+                        if (str[ftIndex - 1] == open[i])
+                        {
+                            int openIdx = ftIndex - 1;
+                            int closeIdx = str.IndexOf(close[i], ftIndex);
+                            if (closeIdx != -1)
+                            {
+                                int add = 0;
+                                if (openIdx > 0 && closeIdx < str.Length - 1 && str[openIdx - 1] == ' ' && str[closeIdx + 1] == ' ')
+                                    add = 1;
+                                str = str.Remove(openIdx, closeIdx - openIdx + 1 + add);
+                                any = true;
+                                break;
+                            }
+                        }
+                    }
+
+                    if (!any)
+                    {
+                        str = str[..ftIndex];
+                    }
                 }
                 else
-                    str = str.Substring(0, ftIndex);
+                {
+                    str = str[..ftIndex];
+                }
+                break;
             }
         }
-        if (onlyIfNonempty)
-            str = str.TrimEnd() == "" ? orig : str;
-        return str.TrimEnd();
+        return changed ? str.TrimEnd() : str;
     }
 
     public static string RemoveConsecutiveWs(this string input)
     {
-        return string.Join(' ', input.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries));
+        if (input.Length == 0)
+            return string.Empty;
+
+        int index = 0;
+        var src = input.ToCharArray();
+        bool skip = false;
+        char ch;
+        for (int i = 0; i < input.Length; i++)
+        {
+            ch = src[i];
+            if (ch == ' ')
+            {
+                if (skip) continue;
+                src[index++] = ch;
+                skip = true;
+            }
+            else
+            {
+                skip = false;
+                src[index++] = ch;
+            }
+        }
+
+        return new string(src, 0, index);
     }
 
     public static string RemoveSquareBrackets(this string str)
     {
+        if (str.Length == 0)
+            return str;
+        if (!str.Contains('['))
+            return str;
         return Regex.Replace(str, @"\[[^\]]*\]", "").Trim();
     }
 
-    public static bool RemoveDiacriticsIfExist(this string s, out string res)
-    {
-        res = s.RemoveDiacritics();
-        return res != s;
-    }
-
     public static bool ContainsIgnoreCase(this string s, string other)
     {
         return s.Contains(other, StringComparison.OrdinalIgnoreCase);
     }
 
-    static char[] boundaryChars = { '-', '|', '.', '\\', '/', '_', '—', '(', ')', '[', ']', ',', '?', '!', ';',
-            '@', ':', '*', '=', '+', '{', '}', '|', '\'', '"', '$', '^', '&', '#', '`', '~', '%', '<', '>' };
-    static string boundaryPattern = "^|$|" + string.Join("|", boundaryChars.Select(c => Regex.Escape(c.ToString())));
+    static readonly HashSet<char> boundarySet = new("-|.\\/_—()[],:?!;@:*=+{}|'\"$^&`~%<>".ToCharArray());
 
     public static bool ContainsWithBoundary(this string str, string value, bool ignoreCase = false)
     {
-        if (value == "")
+        if (value.Length == 0)
             return true;
-        if (str == "")
+        if (str.Length == 0)
             return false;
-        string bound = boundaryPattern + "|\\s";
-        string pattern = $@"({bound}){Regex.Escape(value)}({bound})";
-        RegexOptions options = ignoreCase ? RegexOptions.IgnoreCase : RegexOptions.None;
-        return Regex.IsMatch(str, pattern, options);
+
+        var comp = ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
+
+        int index = 0;
+        while ((index = str.IndexOf(value, index, comp)) != -1)
+        {
+            bool hasLeftBoundary = index == 0 || str[index - 1] == ' ' || boundarySet.Contains(str[index - 1]);
+            bool hasRightBoundary = index + value.Length >= str.Length || str[index + value.Length] == ' ' || boundarySet.Contains(str[index + value.Length]);
+
+            if (hasLeftBoundary && hasRightBoundary)
+                return true;
+
+            index += value.Length;
+        }
+
+        return false;
     }
 
     public static bool ContainsWithBoundaryIgnoreWs(this string str, string value, bool ignoreCase = false, bool acceptLeftDigit = false)
     {
-        if (value == "")
+        if (value.Length == 0)
             return true;
-        if (str == "")
+        if (str.Length == 0)
             return false;
-        string patternLeft = acceptLeftDigit ? boundaryPattern + @"|\d\s+" : boundaryPattern;
-        string pattern = $@"({patternLeft})\s*{Regex.Escape(value)}\s*({boundaryPattern})";
-        RegexOptions options = ignoreCase ? RegexOptions.IgnoreCase : RegexOptions.None;
-        return Regex.IsMatch(str, pattern, options);
-    }
 
+        var comp = ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
+
+        int index = 0;
+        while ((index = str.IndexOf(value, index, comp)) != -1)
+        {
+            int leftIndex = index - 1;
+            while (leftIndex >= 0 && str[leftIndex] == ' ')
+                leftIndex--;
+
+            bool hasLeftBoundary = leftIndex <  0 || acceptLeftDigit && leftIndex < index - 1 && char.IsDigit(str[leftIndex]) || boundarySet.Contains(str[leftIndex]);
+
+            int rightIndex = index + value.Length;
+            while (rightIndex < str.Length && str[rightIndex] == ' ')
+                rightIndex++;
+
+            bool hasRightBoundary = rightIndex >= str.Length || boundarySet.Contains(str[rightIndex]);
+
+            if (hasLeftBoundary && hasRightBoundary)
+                return true;
+
+            index = rightIndex;
+        }
+
+        return false;
+    }
 
     public static bool ContainsInBrackets(this string str, string searchTerm, bool ignoreCase = false)
     {
+        if (str.Length == 0 && searchTerm.Length > 0)
+            return false;
+
         var regex = new Regex(@"\[(.*?)\]|\((.*?)\)");
         var matches = regex.Matches(str);
         var comp = ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
@@ -206,16 +440,6 @@ public static class Utils
         return res != s;
     }
 
-    public static char RemoveDiacritics(this char c)
-    {
-        foreach (var entry in diacriticChars)
-        {
-            if (entry.Key.IndexOf(c) != -1)
-                return entry.Value[0];
-        }
-        return c;
-    }
-
     public static Dictionary<K, V> ToSafeDictionary<T, K, V>(this IEnumerable<T> source, Func<T, K> keySelector, Func<T, V> valSelector)
     {
         var d = new Dictionary<K, V>();
@@ -256,113 +480,222 @@ public static class Utils
         return distance[source.Length, target.Length];
     }
 
-    public static string GreatestCommonPath(IEnumerable<string> paths, char dirsep = '-')
+    public static string GreatestCommonPath(IEnumerable<string> paths, char dirsep)
     {
-        var commonPath = paths.FirstOrDefault();
-        if (string.IsNullOrEmpty(commonPath))
+        string? path = paths.FirstOrDefault();
+
+        if (path == null || path.Length == 0)
             return "";
-        foreach (var path in paths.Skip(1))
+
+        int commonPathIndex(string path1, string path2, int maxIndex)
         {
-            commonPath = GetCommonPath(commonPath, path, dirsep);
+            var minLength = Math.Min(path1.Length, Math.Min(path2.Length, maxIndex));
+            var commonPathLength = 0;
+            for (int i = 0; i < minLength; i++)
+            {
+                if (path1[i] != path2[i])
+                    break;
+                if (path1[i] == dirsep)
+                    commonPathLength = i + 1;
+            }
+            return commonPathLength;
         }
-        return commonPath;
+
+        int index = path.Length;
+
+        foreach (var p in paths.Skip(1))
+            index = commonPathIndex(path, p, index);
+
+        return path[..index];
     }
 
-    private static string GetCommonPath(string path1, string path2, char dirsep = '-')
+    public static bool SequenceEqualUpToPermutation<T>(this IEnumerable<T> list1, IEnumerable<T> list2)
     {
-        if (dirsep == '-')
-            dirsep = Path.DirectorySeparatorChar;
-        var minLength = Math.Min(path1.Length, path2.Length);
-        var commonPathLength = 0;
-        for (int i = 0; i < minLength; i++)
+        var cnt = new Dictionary<T, int>();
+        foreach (T s in list1)
         {
-            if (path1[i] != path2[i])
-                break;
-            if (path1[i] == dirsep)
-                commonPathLength = i + 1;
+            if (cnt.ContainsKey(s))
+                cnt[s]++;
+            else
+                cnt.Add(s, 1);
         }
-        return path1.Substring(0, commonPathLength);
+        foreach (T s in list2)
+        {
+            if (cnt.ContainsKey(s))
+                cnt[s]--;
+            else
+                return false;
+        }
+        return cnt.Values.All(c => c == 0);
+    }
+
+    public static bool RemoveDiacriticsIfExist(this string s, out string res)
+    {
+        res = s.RemoveDiacritics();
+        return res != s;
+    }
+
+    public static char RemoveDiacritics(this char c)
+    {
+        if (diacriticChars.TryGetValue(c, out var res)) return res;
+        return c;
     }
 
     public static string RemoveDiacritics(this string s)
     {
-        string text = "";
+        if (s.Length == 0)
+            return s;
+
+        var textBuilder = new StringBuilder();
         foreach (char c in s)
         {
-            int len = text.Length;
-
-            foreach (var entry in diacriticChars)
-            {
-                if (entry.Key.IndexOf(c) != -1)
-                {
-                    text += entry.Value;
-                    break;
-                }
-            }
-
-            if (len == text.Length)
-                text += c;
+            if (diacriticChars.TryGetValue(c, out char o))
+                textBuilder.Append(o);
+            else
+                textBuilder.Append(c);
         }
-        return text;
+        return textBuilder.ToString();
     }
 
-    static Dictionary<string, string> diacriticChars = new Dictionary<string, string>
+    static readonly Dictionary<char, char> diacriticChars = new()
     {
-        { "ä", "a" },
-        { "æǽ", "ae" },
-        { "œ", "oe" },
-        { "ö", "o" },
-        { "ü", "u" },
-        { "Ä", "A" },
-        { "Ü", "U" },
-        { "Ö", "O" },
-        { "ÀÁÂÃÄÅǺĀĂĄǍΆẢẠẦẪẨẬẰẮẴẲẶ", "A" },
-        { "àáâãåǻāăąǎảạầấẫẩậằắẵẳặа", "a" },
-        { "ÇĆĈĊČ", "C" },
-        { "çćĉċč", "c" },
-        { "ÐĎĐ", "D" },
-        { "ðďđ", "d" },
-        { "ÈÉÊËĒĔĖĘĚΈẼẺẸỀẾỄỂỆ", "E" },
-        { "èéêëēĕėęěẽẻẹềếễểệе", "e" },
-        { "ĜĞĠĢ", "G" },
-        { "ĝğġģ", "g" },
-        { "ĤĦΉ", "H" },
-        { "ĥħ", "h" },
-        { "ÌÍÎÏĨĪĬǏĮİΊΪỈỊЇ", "I" },
-        { "ìíîïĩīĭǐįıίϊỉịї", "i" },
-        { "Ĵ", "J" },
-        { "ĵ", "j" },
-        { "Ķ", "K" },
-        { "ķ", "k" },
-        { "ĹĻĽĿŁ", "L" },
-        { "ĺļľŀł", "l" },
-        { "ÑŃŅŇ", "N" },
-        { "ñńņňʼn", "n" },
-        { "ÒÓÔÕŌŎǑŐƠØǾΌỎỌỒỐỖỔỘỜỚỠỞỢ", "O" },
-        { "òóôõōŏǒőơøǿºόỏọồốỗổộờớỡởợ", "o" },
-        { "ŔŖŘ", "R" },
-        { "ŕŗř", "r" },
-        { "ŚŜŞȘŠ", "S" },
-        { "śŝşșš", "s" },
-        { "ȚŢŤŦТ", "T" },
-        { "țţťŧ", "t" },
-        { "ÙÚÛŨŪŬŮŰŲƯǓǕǗǙǛŨỦỤỪỨỮỬỰ", "U" },
-        { "ùúûũūŭůűųưǔǖǘǚǜủụừứữửự", "u" },
-        { "ÝŸŶΎΫỲỸỶỴ", "Y" },
-        { "Й", "Й" },
-        { "й", "и" },
-        { "ýÿŷỳỹỷỵ", "y" },
-        { "Ŵ", "W" },
-        { "ŵ", "w" },
-        { "ŹŻŽ", "Z" },
-        { "źżž", "z" },
-        { "ÆǼ", "AE" },
-        { "ß", "ss" },
-        { "IJ", "IJ" },
-        { "ij", "ij" },
-        { "Œ", "OE" },
-        { "Ё", "Е" },
-        { "ё", "е" },
+        { 'ä', 'a' }, { 'æ', 'a' }, { 'ǽ', 'a' }, { 'œ', 'o' }, { 'ö', 'o' }, { 'ü', 'u' },
+        { 'Ä', 'A' }, { 'Ü', 'U' }, { 'Ö', 'O' }, { 'À', 'A' }, { 'Á', 'A' }, { 'Â', 'A' },
+        { 'Ã', 'A' }, { 'Å', 'A' }, { 'Ǻ', 'A' }, { 'Ā', 'A' }, { 'Ă', 'A' }, { 'Ą', 'A' },
+        { 'Ǎ', 'A' }, { 'Ά', 'A' }, { 'Ả', 'A' }, { 'Ạ', 'A' }, { 'Ầ', 'A' }, { 'Ấ', 'A' },
+        { 'Ẫ', 'A' }, { 'Ẩ', 'A' }, { 'Ậ', 'A' }, { 'à', 'a' }, { 'á', 'a' }, { 'â', 'a' },
+        { 'ã', 'a' }, { 'å', 'a' }, { 'ǻ', 'a' }, { 'ā', 'a' }, { 'ă', 'a' }, { 'ą', 'a' },
+        { 'ǎ', 'a' }, { 'ả', 'a' }, { 'ạ', 'a' }, { 'Ç', 'C' }, { 'Ć', 'C' }, { 'Ĉ', 'C' },
+        { 'Ċ', 'C' }, { 'Č', 'C' }, { 'ç', 'c' }, { 'ć', 'c' }, { 'ĉ', 'c' }, { 'ċ', 'c' },
+        { 'č', 'c' }, { 'Ð', 'D' }, { 'Ď', 'D' }, { 'Đ', 'D' }, { 'ð', 'd' }, { 'ď', 'd' },
+        { 'đ', 'd' }, { 'È', 'E' }, { 'É', 'E' }, { 'Ê', 'E' }, { 'Ë', 'E' }, { 'Ē', 'E' },
+        { 'Ĕ', 'E' }, { 'Ė', 'E' }, { 'Ę', 'E' }, { 'Ě', 'E' }, { 'Έ', 'E' }, { 'Ẽ', 'E' },
+        { 'Ẻ', 'E' }, { 'Ẹ', 'E' }, { 'Ề', 'E' }, { 'Ế', 'E' }, { 'Ễ', 'E' }, { 'Ể', 'E' },
+        { 'Ệ', 'E' }, { 'è', 'e' }, { 'é', 'e' }, { 'ê', 'e' }, { 'ë', 'e' }, { 'ē', 'e' },
+        { 'ĕ', 'e' }, { 'ė', 'e' }, { 'ę', 'e' }, { 'ě', 'e' }, { 'ẽ', 'e' }, { 'ẻ', 'e' },
+        { 'ẹ', 'e' }, { 'Ĝ', 'G' }, { 'Ğ', 'G' }, { 'Ġ', 'G' }, { 'Ģ', 'G' }, { 'ĝ', 'g' },
+        { 'ğ', 'g' }, { 'ġ', 'g' }, { 'ģ', 'g' }, { 'Ĥ', 'H' }, { 'Ħ', 'H' }, { 'Ή', 'H' },
+        { 'ĥ', 'h' }, { 'ħ', 'h' }, { 'Ì', 'I' }, { 'Í', 'I' }, { 'Î', 'I' }, { 'Ï', 'I' },
+        { 'Ĩ', 'I' }, { 'Ī', 'I' }, { 'Ĭ', 'I' }, { 'Ǐ', 'I' }, { 'Į', 'I' }, { 'İ', 'I' },
+        { 'Ί', 'I' }, { 'Ϊ', 'I' }, { 'Ỉ', 'I' }, { 'Ị', 'I' }, { 'Ї', 'I' }, { 'ì', 'i' },
+        { 'í', 'i' }, { 'î', 'i' }, { 'ï', 'i' }, { 'ĩ', 'i' }, { 'ī', 'i' }, { 'ĭ', 'i' },
+        { 'ǐ', 'i' }, { 'į', 'i' }, { 'ı', 'i' }, { 'ΰ', 'y' }, { 'Ĵ', 'J' }, { 'ĵ', 'j' },
+        { 'Ķ', 'K' }, { 'ķ', 'k' }, { 'Ĺ', 'L' }, { 'Ļ', 'L' }, { 'Ľ', 'L' }, { 'Ŀ', 'L' },
+        { 'Ł', 'L' }, { 'ĺ', 'l' }, { 'ļ', 'l' }, { 'ľ', 'l' }, { 'ŀ', 'l' }, { 'ł', 'l' },
+        { 'Ñ', 'N' }, { 'Ń', 'N' }, { 'Ņ', 'N' }, { 'Ň', 'N' }, { 'ñ', 'n' }, { 'ń', 'n' },
+        { 'ņ', 'n' }, { 'ň', 'n' }, { 'ʼn', 'n' }, { 'Ò', 'O' }, { 'Ó', 'O' }, { 'Ô', 'O' },
+        { 'Õ', 'O' }, { 'Ō', 'O' }, { 'Ŏ', 'O' }, { 'Ǒ', 'O' }, { 'Ő', 'O' }, { 'Ơ', 'O' },
+        { 'Ø', 'O' }, { 'Ǿ', 'O' }, { 'Ό', 'O' }, { 'Ỏ', 'O' }, { 'Ọ', 'O' }, { 'Ồ', 'O' },
+        { 'Ố', 'O' }, { 'Ỗ', 'O' }, { 'Ổ', 'O' }, { 'Ộ', 'O' }, { 'Ờ', 'O' }, { 'Ớ', 'O' },
+        { 'Ỡ', 'O' }, { 'Ở', 'O' }, { 'Ợ', 'O' }, { 'ò', 'o' }, { 'ó', 'o' }, { 'ô', 'o' },
+        { 'õ', 'o' }, { 'ō', 'o' }, { 'ŏ', 'o' }, { 'ǒ', 'o' }, { 'ő', 'o' }, { 'ơ', 'o' },
+        { 'ø', 'o' }, { 'ǿ', 'o' }, { 'º', 'o' }, { 'ό', 'o' }, { 'ỏ', 'o' }, { 'ọ', 'o' },
+        { 'ồ', 'o' }, { 'ố', 'o' }, { 'ỗ', 'o' }, { 'ổ', 'o' }, { 'ộ', 'o' }, { 'ờ', 'o' },
+        { 'ớ', 'o' }, { 'ỡ', 'o' }, { 'ở', 'o' }, { 'ợ', 'o' }, { 'Ŕ', 'R' }, { 'Ŗ', 'R' },
+        { 'Ř', 'R' }, { 'ŕ', 'r' }, { 'ŗ', 'r' }, { 'ř', 'r' }, { 'Ś', 'S' }, { 'Ŝ', 'S' },
+        { 'Ş', 'S' }, { 'Ș', 'S' }, { 'Š', 'S' }, { 'ś', 's' }, { 'ŝ', 's' }, { 'ş', 's' },
+        { 'ș', 's' }, { 'š', 's' }, { 'Ț', 'T' }, { 'Ţ', 'T' }, { 'Ť', 'T' }, { 'Ŧ', 'T' },
+        { 'Т', 'T' }, { 'ț', 't' }, { 'ţ', 't' }, { 'ť', 't' }, { 'ŧ', 't' }, { 'Ù', 'U' },
+        { 'Ú', 'U' }, { 'Û', 'U' }, { 'Ũ', 'U' }, { 'Ū', 'U' }, { 'Ŭ', 'U' }, { 'Ů', 'U' },
+        { 'Ű', 'U' }, { 'Ų', 'U' }, { 'Ư', 'U' }, { 'Ǔ', 'U' }, { 'Ǖ', 'U' }, { 'Ǘ', 'U' },
+        { 'Ǚ', 'U' }, { 'Ǜ', 'U' }, { 'Ủ', 'U' }, { 'Ụ', 'U' }, { 'Ừ', 'U' }, { 'ё', 'e' },
+        { 'Ứ', 'U' }, { 'Ữ', 'U' }, { 'Ử', 'U' }, { 'Ự', 'U' }, { 'ù', 'u' }, { 'ú', 'u' },
+        { 'û', 'u' }, { 'ũ', 'u' }, { 'ū', 'u' }, { 'ŭ', 'u' }, { 'ů', 'u' }, { 'ű', 'u' },
+        { 'ų', 'u' }, { 'ư', 'u' }, { 'ǔ', 'u' }, { 'ǖ', 'u' }, { 'ǘ', 'u' }, { 'ǚ', 'u' },
+        { 'ǜ', 'u' }, { 'ủ', 'u' }, { 'ụ', 'u' }, { 'ừ', 'u' }, { 'ứ', 'u' }, { 'ữ', 'u' },
+        { 'ử', 'u' }, { 'ự', 'u' }, { 'Ý', 'Y' }, { 'Ÿ', 'Y' }, { 'Ŷ', 'Y' }, { 'Ύ', 'Y' },
+        { 'Ϋ', 'Y' }, { 'Ỳ', 'Y' }, { 'Ỹ', 'Y' }, { 'Ỷ', 'Y' }, { 'Ỵ', 'Y' }, { 'й', 'и' },
+        { 'ý', 'y' }, { 'ÿ', 'y' }, { 'ŷ', 'y' }, { 'ỳ', 'y' }, { 'ỹ', 'y' }, { 'ỷ', 'y' },
+        { 'ỵ', 'y' }, { 'Ŵ', 'W' }, { 'ŵ', 'w' }, { 'Ź', 'Z' }, { 'Ż', 'Z' }, { 'Ž', 'Z' },
+        { 'ź', 'z' }, { 'ż', 'z' }, { 'ž', 'z' }, { 'Æ', 'A' }, { 'ß', 's' }, { 'Œ', 'O' },
+        { 'Ё', 'E' },
     };
 }
 
+
+class RateLimitedSemaphore
+{
+    private readonly int maxCount;
+    private readonly TimeSpan resetTimeSpan;
+    private readonly SemaphoreSlim semaphore;
+    private long nextResetTimeTicks;
+    private readonly object resetTimeLock = new object();
+
+    public RateLimitedSemaphore(int maxCount, TimeSpan resetTimeSpan)
+    {
+        this.maxCount = maxCount;
+        this.resetTimeSpan = resetTimeSpan;
+        this.semaphore = new SemaphoreSlim(maxCount, maxCount);
+        this.nextResetTimeTicks = (DateTimeOffset.UtcNow + this.resetTimeSpan).UtcTicks;
+    }
+
+    private void TryResetSemaphore()
+    {
+        if (!(DateTimeOffset.UtcNow.UtcTicks > Interlocked.Read(ref this.nextResetTimeTicks)))
+            return;
+
+        lock (this.resetTimeLock)
+        {
+            var currentTime = DateTimeOffset.UtcNow;
+            if (currentTime.UtcTicks > Interlocked.Read(ref this.nextResetTimeTicks))
+            {
+                int releaseCount = this.maxCount - this.semaphore.CurrentCount;
+                if (releaseCount > 0)
+                    this.semaphore.Release(releaseCount);
+
+                var newResetTimeTicks = (currentTime + this.resetTimeSpan).UtcTicks;
+                Interlocked.Exchange(ref this.nextResetTimeTicks, newResetTimeTicks);
+            }
+        }
+    }
+
+    public async Task WaitAsync()
+    {
+        TryResetSemaphore();
+        var semaphoreTask = this.semaphore.WaitAsync();
+
+        while (!semaphoreTask.IsCompleted)
+        {
+            var ticks = Interlocked.Read(ref this.nextResetTimeTicks);
+            var nextResetTime = new DateTimeOffset(new DateTime(ticks, DateTimeKind.Utc));
+            var delayTime = nextResetTime - DateTimeOffset.UtcNow;
+            var delayTask = delayTime >= TimeSpan.Zero ? Task.Delay(delayTime) : Task.CompletedTask;
+
+            await Task.WhenAny(semaphoreTask, delayTask);
+            TryResetSemaphore();
+        }
+    }
+}
+
+public static class Logger
+{
+    public static Verbosity verbosity { get; set; } = Verbosity.Normal;
+
+    public static void Log(string message, Verbosity messageLevel)
+    {
+        if (messageLevel <= verbosity)
+        {
+            Console.WriteLine(message);
+        }
+    }
+
+    public static void Error(string message)
+    {
+        Log(message, Verbosity.Error);
+    }
+
+    public static void Warning(string message)
+    {
+        Log(message, Verbosity.Warning);
+    }
+
+    public static void Info(string message)
+    {
+        Log(message, Verbosity.Normal);
+    }
+
+    public static void Verbose(string message)
+    {
+        Log(message, Verbosity.Verbose);
+    }
+}
diff --git a/slsk-batchdl/YouTube.cs b/slsk-batchdl/YouTube.cs
deleted file mode 100644
index 3075a76..0000000
--- a/slsk-batchdl/YouTube.cs
+++ /dev/null
@@ -1,610 +0,0 @@
-using Google.Apis.YouTube.v3;
-using Google.Apis.Services;
-using System.Xml;
-using YoutubeExplode;
-using System.Text.RegularExpressions;
-using YoutubeExplode.Common;
-using System.Diagnostics;
-using HtmlAgilityPack;
-using System.Collections.Concurrent;
-
-public static class YouTube
-{
-    private static YoutubeClient? youtube = new YoutubeClient();
-    private static YouTubeService? youtubeService = null;
-    public static string apiKey = "";
-
-    public static async Task<(string, List<Track>)> GetTracksApi(string url, int max = int.MaxValue, int offset = 0)
-    {
-        StartService();
-
-        string playlistId = await UrlToId(url);
-
-        var playlistRequest = youtubeService.Playlists.List("snippet");
-        playlistRequest.Id = playlistId;
-        var playlistResponse = playlistRequest.Execute();
-
-        string playlistName = playlistResponse.Items[0].Snippet.Title;
-
-        var playlistItemsRequest = youtubeService.PlaylistItems.List("snippet,contentDetails");
-        playlistItemsRequest.PlaylistId = playlistId;
-        playlistItemsRequest.MaxResults = Math.Min(max, 100);
-
-        var tracksDict = await GetDictYtExplode(url, max, offset);
-        var tracks = new List<Track>();
-        int count = 0;
-
-        while (playlistItemsRequest != null && count < max + offset)
-        {
-            var playlistItemsResponse = playlistItemsRequest.Execute();
-            foreach (var playlistItem in playlistItemsResponse.Items)
-            {
-                if (count >= offset)
-                {
-                    if (tracksDict.ContainsKey(playlistItem.Snippet.ResourceId.VideoId))
-                        tracks.Add(tracksDict[playlistItem.Snippet.ResourceId.VideoId]);
-                    else
-                    {
-                        var title = "";
-                        var uploader = "";
-                        var length = 0;
-                        var desc = "";
-
-                        var videoRequest = youtubeService.Videos.List("contentDetails,snippet");
-                        videoRequest.Id = playlistItem.Snippet.ResourceId.VideoId;
-                        var videoResponse = videoRequest.Execute();
-
-                        title = playlistItem.Snippet.Title;
-                        if (videoResponse.Items.Count == 0)
-                            continue;
-                        uploader = videoResponse.Items[0].Snippet.ChannelTitle;
-                        length = (int)XmlConvert.ToTimeSpan(videoResponse.Items[0].ContentDetails.Duration).TotalSeconds;
-                        desc = videoResponse.Items[0].Snippet.Description;
-
-                        Track track = await ParseTrackInfo(title, uploader, playlistItem.Snippet.ResourceId.VideoId, length, desc);
-                        tracks.Add(track);
-                    }
-                }
-
-                if (++count >= max + offset)
-                    break;
-            }
-
-            if (tracksDict.Count >= 200 && !Console.IsOutputRedirected)
-            {
-                Console.SetCursorPosition(0, Console.CursorTop);
-                Console.Write($"Loaded: {tracks.Count}");
-            }
-
-            playlistItemsRequest.PageToken = playlistItemsResponse.NextPageToken;
-            if (playlistItemsRequest.PageToken == null || count >= max + offset)
-                playlistItemsRequest = null;
-            else
-                playlistItemsRequest.MaxResults = Math.Min(offset + max - count, 100);
-        }
-
-        Console.WriteLine();
-
-        return (playlistName, tracks);
-    }
-
-    // requestInfoIfNeeded=true is way too slow
-    public static async Task<Track> ParseTrackInfo(string title, string uploader, string id, int length, string desc = "", bool requestInfoIfNeeded=false)
-    {
-        (string title, string uploader, int length, string desc) info = ("", "", -1, "");
-        var track = new Track();
-        track.URI = id;
-
-        uploader = uploader.Replace("–", "-").Trim().RemoveConsecutiveWs();
-        title = title.Replace("–", "-").Replace(" -- ", " - ").Trim().RemoveConsecutiveWs();
-
-        var artist = uploader;
-        var trackTitle = title;
-
-        if (artist.EndsWith(" - Topic"))
-        {
-            artist = artist.Substring(0, artist.Length - 7).Trim();
-            trackTitle = title;
-
-            if (artist == "Various Artists")
-            {
-                if (desc == "" && requestInfoIfNeeded && id != "")
-                {
-                    info = await GetVideoInfo(id);
-                    desc = info.desc;
-                }
-                
-                if (desc != "")
-                {
-                    var lines = desc.Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries);
-                    var dotLine = lines.FirstOrDefault(line => line.Contains(" · "));
-
-                    if (dotLine != null)
-                        artist = dotLine.Split(new[] { " · " }, StringSplitOptions.None)[1];
-                }
-            }
-        }
-        else
-        {
-            track.ArtistMaybeWrong = !title.ContainsWithBoundary(artist, true) && !desc.ContainsWithBoundary(artist, true);
-
-            var split = title.Split(" - ", StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries);
-            if (split.Length == 2)
-            {
-                artist = split[0];
-                trackTitle = split[1];
-                track.ArtistMaybeWrong = false;
-            }
-            else if (split.Length > 2)
-            {
-                int index = Array.FindIndex(split, s => s.ContainsWithBoundary(artist, true));
-                if (index != -1 && index < split.Length - 1)
-                {
-                    artist = split[index];
-                    trackTitle = String.Join(" - ", split[(index + 1)..]);
-                    track.ArtistMaybeWrong = false;
-                }
-            }
-
-            if (track.ArtistMaybeWrong && requestInfoIfNeeded && desc == "")
-            {
-                info = await GetVideoInfo(id);
-                track.ArtistMaybeWrong = !info.desc.ContainsWithBoundary(artist, true);
-            }
-        }
-
-        if (length <= 0 && id != "" && requestInfoIfNeeded)
-        {
-            if (info.length > 0)
-                length = info.length;
-            else
-            {
-                info = await GetVideoInfo(id);
-                length = info.length;
-            }
-        }
-
-        track.Length = length;
-        track.Artist = artist;
-        track.Title = trackTitle;
-
-        return track;
-    }
-
-    public static async Task<(string title, string uploader, int length, string desc)> GetVideoInfo(string id)
-    {
-        (string title, string uploader, int length, string desc) o = ("", "", -1, "");
-        
-        try
-        {
-            var vid = await youtube.Videos.GetAsync(id);
-            o.title = vid.Title;
-            o.uploader = vid.Author.ChannelTitle;
-            o.desc = vid.Description;
-            o.length = (int)vid.Duration.Value.TotalSeconds;
-        }
-        catch
-        {
-            if (apiKey != "")
-            {
-                try
-                {
-                    StartService();
-                    var videoRequest = youtubeService.Videos.List("contentDetails,snippet");
-                    videoRequest.Id = id;
-                    var videoResponse = videoRequest.Execute();
-
-                    o.title = videoResponse.Items[0].Snippet.Title;
-                    o.uploader = videoResponse.Items[0].Snippet.ChannelTitle;
-                    o.length = (int)XmlConvert.ToTimeSpan(videoResponse.Items[0].ContentDetails.Duration).TotalSeconds;
-                    o.desc = videoResponse.Items[0].Snippet.Description;
-                }
-                catch { }
-            }
-        }
-
-        return o;
-    }
-
-    public static void StartService()
-    {
-        if (youtubeService == null)
-        {
-            if (apiKey == "")
-                throw new Exception("No API key");
-
-            youtubeService = new YouTubeService(new BaseClientService.Initializer()
-            {
-                ApiKey = apiKey,
-                ApplicationName = "slsk-batchdl"
-            });
-        }
-    }
-
-    public static void StopService()
-    {
-        youtubeService = null;
-    }
-
-    public static async Task<Dictionary<string, Track>> GetDictYtExplode(string url, int max = int.MaxValue, int offset = 0)
-    {
-        var youtube = new YoutubeClient();
-        var playlist = await youtube.Playlists.GetAsync(url);
-
-        var tracks = new Dictionary<string, Track>();
-        int count = 0;
-
-        await foreach (var video in youtube.Playlists.GetVideosAsync(playlist.Id))
-        {
-            if (count >= offset && count < offset + max)
-            {
-                var title = video.Title;
-                var uploader = video.Author.Title;
-                var ytId = video.Id.Value;
-                var length = (int)video.Duration.Value.TotalSeconds;
-
-                var track = await ParseTrackInfo(title, uploader, ytId, length);
-
-                tracks[ytId] = track;
-            }
-
-            if (count++ >= offset + max)
-                break;
-        }
-
-        return tracks;
-    }
-
-    public static async Task<string> GetPlaylistTitle(string url)
-    {
-        var youtube = new YoutubeClient();
-        var playlist = await youtube.Playlists.GetAsync(url);
-        return playlist.Title;
-    }
-
-    public static async Task<(string, List<Track>)> GetTracksYtExplode(string url, int max = int.MaxValue, int offset = 0)
-    {
-        var youtube = new YoutubeClient();
-        var playlist = await youtube.Playlists.GetAsync(url);
-
-        var playlistTitle = playlist.Title;
-        var tracks = new List<Track>();
-        int count = 0;
-
-        await foreach (var video in youtube.Playlists.GetVideosAsync(playlist.Id))
-        {
-            if (count >= offset && count < offset + max)
-            {
-                var title = video.Title;
-                var uploader = video.Author.Title;
-                var ytId = video.Id.Value;
-                var length = (int)video.Duration.Value.TotalSeconds;
-
-                var track = await ParseTrackInfo(title, uploader, ytId, length);
-
-                tracks.Add(track);
-            }
-
-            if (count++ >= offset + max)
-                break;
-        }
-
-        return (playlistTitle, tracks);
-    }
-
-
-    public static async Task<string> UrlToId(string url)
-    {
-        var playlist = await youtube.Playlists.GetAsync(url);
-        return playlist.Id.ToString();
-    }
-
-    public class YouTubeArchiveRetriever
-    {
-        private HttpClient _client;
-
-        public YouTubeArchiveRetriever()
-        {
-            _client = new HttpClient();
-            _client.Timeout = TimeSpan.FromSeconds(10);
-        }
-
-        public async Task<List<Track>> RetrieveDeleted(string url, bool printFailed = true)
-        {
-            var deletedVideoUrls = new BlockingCollection<string>();
-
-            int totalCount = 0;
-            int archivedCount = 0;
-            var tracks = new ConcurrentBag<Track>();
-            var noArchive = new ConcurrentBag<string>();
-            var failRetrieve = new ConcurrentBag<string>();
-
-            int workerCount = 4;
-            var workers = new List<Task>();
-            var consoleLock = new object();
-
-            void updateInfo()
-            {
-                lock (consoleLock)
-                {
-                    if (!Console.IsOutputRedirected)
-                    {
-                        string info = "Deleted metadata total/archived/retrieved: ";
-                        Console.SetCursorPosition(0, Console.CursorTop);
-                        Console.Write($"{info}{totalCount}/{archivedCount}/{tracks.Count}");
-                    }
-                }
-            }
-
-            var process = new Process
-            {
-                StartInfo = new ProcessStartInfo
-                {
-                    FileName = "yt-dlp",
-                    Arguments = $"--ignore-no-formats-error --no-warn --match-filter \"!uploader\" --print webpage_url {url}",
-                    RedirectStandardOutput = true,
-                    UseShellExecute = false,
-                    CreateNoWindow = true,
-                },
-                EnableRaisingEvents = true
-            };
-            process.OutputDataReceived += (sender, e) =>
-            {
-                if (!string.IsNullOrWhiteSpace(e.Data))
-                {
-                    deletedVideoUrls.Add(e.Data);
-                    Interlocked.Increment(ref totalCount);
-                    updateInfo();
-                }
-            };
-            process.Exited += (sender, e) =>
-            {
-                deletedVideoUrls.CompleteAdding();
-            };
-
-            process.Start();
-            process.BeginOutputReadLine();
-
-            for (int i = 0; i < workerCount; i++)
-            {
-                workers.Add(Task.Run(async () =>
-                {
-                    foreach (var videoUrl in deletedVideoUrls.GetConsumingEnumerable())
-                    {
-                        var waybackUrls = await GetOldestArchiveUrls(videoUrl, limit: 2);
-                        if (waybackUrls != null && waybackUrls.Count > 0)
-                        {
-                            Interlocked.Increment(ref archivedCount);
-
-                            bool good = false;
-                            foreach (var waybackUrl in waybackUrls)
-                            {
-                                var (title, uploader, duration) = await GetVideoDetails(waybackUrl);
-                                if (!string.IsNullOrWhiteSpace(title))
-                                {
-                                    var track = await ParseTrackInfo(title, uploader, waybackUrl, duration);
-                                    track.Other = $"{{\"t\":\"{title.Trim()}\",\"u\":\"{uploader.Trim()}\"}}";
-                                    tracks.Add(track);
-                                    good = true;
-                                    break;
-                                }
-                            }
-
-                            if (!good)
-                            {
-                                failRetrieve.Add(waybackUrls[0]);
-                            }
-                        }
-                        else
-                        {
-                            noArchive.Add(videoUrl);
-                        }
-
-                        updateInfo();
-                    }
-                }));
-            }
-
-            await Task.WhenAll(workers);
-            process.WaitForExit();
-            deletedVideoUrls.CompleteAdding();
-            Console.WriteLine();
-
-            if (printFailed)
-            {
-                if (archivedCount < totalCount)
-                {
-                    Console.WriteLine("No archived version found for the following:");
-                    foreach (var x in noArchive)
-                        Console.WriteLine($"  {x}");
-                    Console.WriteLine();
-                    
-                }
-                if (tracks.Count < archivedCount)
-                {
-                    Console.WriteLine("Failed to parse archived version for the following:");
-                    foreach (var x in failRetrieve)
-                        Console.WriteLine($"  {x}");
-                    Console.WriteLine();
-                }
-            }
-
-            return tracks.ToList();
-        }
-
-        private async Task<List<string>> GetOldestArchiveUrls(string url, int limit)
-        {
-            var url2 = $"http://web.archive.org/cdx/search/cdx?url={url}&fl=timestamp,original&filter=statuscode:200&sort=timestamp:asc&limit={limit}";
-            HttpResponseMessage response = null;
-            for (int i = 0; i < 3; i++)
-            {
-                try {
-                    response = await _client.GetAsync(url2);
-                    break;
-                }
-                catch (Exception e) { }
-            }
-            if (response == null) return null;
-            
-            if (response.IsSuccessStatusCode)
-            {
-                var content = await response.Content.ReadAsStringAsync();
-                var lines = content.Split("\n").Where(line => !string.IsNullOrWhiteSpace(line)).ToList();
-                if (lines.Count > 0)
-                {
-                    for (int i = 0; i < lines.Count; i++)
-                    {
-                        var parts = lines[i].Split(" ");
-                        var timestamp = parts[0];
-                        var originalUrl = parts[1];
-                        lines[i] = $"http://web.archive.org/web/{timestamp}/{originalUrl}";
-                    }
-                    return lines;
-                }
-            }
-            return null;
-        }
-
-        public async Task<(string title, string uploader, int duration)> GetVideoDetails(string url)
-        {
-            var web = new HtmlWeb();
-            var doc = await web.LoadFromWebAsync(url);
-
-            var titlePatterns = new[]
-            {
-                "//h1[@id='video_title']",
-                "//meta[@name='title']",
-            };
-
-            var usernamePatterns = new[]
-            {
-                "//div[@id='userInfoDiv']/b/a",
-                "//a[contains(@class, 'contributor')]",
-                "//a[@id='watch-username']",
-                "//a[contains(@class, 'author')]",
-                "//div[@class='yt-user-info']/a",
-                "//div[@id='upload-info']//yt-formatted-string/a",
-                "//span[@itemprop='author']//link[@itemprop='name']",
-                "//a[contains(@class, 'yt-user-name')]",
-            };
-
-            string getItem(string[] patterns)
-            {
-                foreach (var pattern in patterns)
-                {
-                    var node = doc.DocumentNode.SelectSingleNode(pattern);
-                    if (node != null)
-                    {
-                        var res = "";
-                        if (pattern.StartsWith("//meta") || pattern.Contains("@itemprop"))
-                            res = node.GetAttributeValue("content", "");
-                        else
-                            res = node.InnerText;
-                        if (!string.IsNullOrEmpty(res)) 
-                            return Utils.UnHtmlString(res);
-                    }
-                }
-                return "";
-            }
-
-            var title = getItem(titlePatterns);
-            if (string.IsNullOrEmpty(title))
-            {
-                var pattern = @"document\.title\s*=\s*""(.+?) - YouTube"";";
-                var match = Regex.Match(doc.Text, pattern);
-                if (match.Success)
-                    title = match.Groups[1].Value;
-            }
-
-            var username = getItem(usernamePatterns);
-
-            int duration = -1;
-            var node = doc.DocumentNode.SelectSingleNode("//meta[@itemprop='duration']");
-            if (node != null)
-            {
-                try
-                {
-                    duration = (int)XmlConvert.ToTimeSpan(node.GetAttributeValue("content", "")).TotalSeconds;
-                }
-                catch { }
-            }
-                
-            return (title, username, duration);
-        }
-    }
-
-    public static async Task<List<(int length, string id, string title)>> YtdlpSearch(Track track)
-    {
-        Process process = new Process();
-        ProcessStartInfo startInfo = new ProcessStartInfo();
-
-        startInfo.FileName = "yt-dlp";
-        string search = track.Artist != "" ? $"{track.Artist} - {track.Title}" : track.Title;
-        startInfo.Arguments = $"\"ytsearch3:{search}\" --print \"%(duration>%s)s === %(id)s === %(title)s\"";
-
-        startInfo.RedirectStandardOutput = true;
-        startInfo.RedirectStandardError = true;
-        startInfo.UseShellExecute = false;
-        process.StartInfo = startInfo;
-        process.OutputDataReceived += (sender, e) => { Console.WriteLine(e.Data); };
-        process.ErrorDataReceived += (sender, e) => { Console.WriteLine(e.Data); };
-
-        process.Start();
-
-        List<(int, string, string)> results = new List<(int, string, string)>();
-        string output;
-        Regex regex = new Regex(@"^(\d+) === ([\w-]+) === (.+)$");
-        while ((output = process.StandardOutput.ReadLine()) != null)
-        {
-            Match match = regex.Match(output);
-            if (match.Success)
-            {
-                int seconds = int.Parse(match.Groups[1].Value);
-                string id = match.Groups[2].Value;
-                string title = match.Groups[3].Value;
-                results.Add((seconds, id, title));
-            }
-        }
-
-        process.WaitForExit();
-        return results;
-    }
-
-    public static async Task<string> YtdlpDownload(string id, string savePathNoExt, string ytdlpArgument="")
-    {
-        Process process = new Process();
-        ProcessStartInfo startInfo = new ProcessStartInfo();
-
-        if (ytdlpArgument == "")
-            ytdlpArgument = "\"{id}\" -f bestaudio/best -ci -o \"{savepath-noext}.%(ext)s\" -x";
-
-        startInfo.FileName = "yt-dlp";
-        startInfo.Arguments = ytdlpArgument
-            .Replace("{id}", id)
-            .Replace("{savepath}", savePathNoExt)
-            .Replace("{savepath-noext}", savePathNoExt)
-            .Replace("{savedir}", Path.GetDirectoryName(savePathNoExt));
-
-        startInfo.RedirectStandardOutput = true;
-        startInfo.RedirectStandardError = true;
-        startInfo.UseShellExecute = false;
-        process.StartInfo = startInfo;
-        //process.OutputDataReceived += (sender, e) => { Console.WriteLine(e.Data); };
-        //process.ErrorDataReceived += (sender, e) => { Console.WriteLine(e.Data); };
-
-        process.Start();
-        process.WaitForExit();
-
-        if (File.Exists(savePathNoExt + ".opus"))
-            return savePathNoExt + ".opus";
-
-        string parentDirectory = Path.GetDirectoryName(savePathNoExt);
-        string[] musicFiles = Directory.GetFiles(parentDirectory, "*", SearchOption.TopDirectoryOnly)
-                                        .Where(file => Utils.IsMusicFile(file))
-                                        .ToArray();
-        if (musicFiles.Length > 0)
-            return musicFiles[0];
-
-        return "";
-    }
-}
diff --git a/slsk-batchdl/slsk-batchdl.csproj b/slsk-batchdl/slsk-batchdl.csproj
index 6272f09..8c1b2e2 100644
--- a/slsk-batchdl/slsk-batchdl.csproj
+++ b/slsk-batchdl/slsk-batchdl.csproj
@@ -1,22 +1,22 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>net6.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
+     <Nullable>enable</Nullable> 
     <AssemblyName>sldl</AssemblyName>
+	<VersionPrefix>2.3</VersionPrefix>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
     <DefineConstants>$(DefineConstants);TRACE</DefineConstants>
+    <DebugType>portable</DebugType>
   </PropertyGroup>
 
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'" />
-
-  <ItemGroup>
-    <Compile Remove="Test.cs" />
-  </ItemGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+    <DebugType>portable</DebugType>
+  </PropertyGroup>
 
   <ItemGroup>
     <PackageReference Include="Goblinfactory.ProgressBar" Version="1.0.0" />
@@ -27,7 +27,11 @@
     <PackageReference Include="SpotifyAPI.Web" Version="7.1.1" />
     <PackageReference Include="SpotifyAPI.Web.Auth" Version="7.1.1" />
     <PackageReference Include="TagLibSharp" Version="2.3.0" />
-    <PackageReference Include="YoutubeExplode" Version="6.3.16" />
+    <PackageReference Include="YoutubeExplode" Version="6.4.0" />
+  </ItemGroup>
+  
+  <ItemGroup>
+	<Compile Remove="Test.cs" Condition="'$(Configuration)' == 'Release'" />
   </ItemGroup>
 
 </Project>