diff --git a/.idea/runConfigurations/Clippy.xml b/.idea/runConfigurations/Clippy.xml
index 706202c1..f4af1cd7 100644
--- a/.idea/runConfigurations/Clippy.xml
+++ b/.idea/runConfigurations/Clippy.xml
@@ -5,7 +5,7 @@
     <envs />
     <option name="emulateTerminal" value="true" />
     <option name="channel" value="DEFAULT" />
-    <option name="requiredFeatures" value="true" />
+    <option name="requiredFeatures" value="false" />
     <option name="allFeatures" value="false" />
     <option name="withSudo" value="false" />
     <option name="buildTarget" value="REMOTE" />
diff --git a/.idea/runConfigurations/Run__debug_.xml b/.idea/runConfigurations/Run__debug_.xml
deleted file mode 100644
index 1d7deb10..00000000
--- a/.idea/runConfigurations/Run__debug_.xml
+++ /dev/null
@@ -1,21 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Run (debug)" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
-    <option name="command" value="run --package royalnet --bin royalnet" />
-    <option name="workingDirectory" value="file://$PROJECT_DIR$" />
-    <envs>
-      <env name="RUST_LOG" value="royalnet" />
-    </envs>
-    <option name="emulateTerminal" value="true" />
-    <option name="channel" value="DEFAULT" />
-    <option name="requiredFeatures" value="true" />
-    <option name="allFeatures" value="false" />
-    <option name="withSudo" value="false" />
-    <option name="buildTarget" value="REMOTE" />
-    <option name="backtrace" value="SHORT" />
-    <option name="isRedirectInput" value="false" />
-    <option name="redirectInputPath" value="" />
-    <method v="2">
-      <option name="CARGO.BUILD_TASK_PROVIDER" enabled="true" />
-    </method>
-  </configuration>
-</component>
\ No newline at end of file
diff --git a/Cargo.lock b/Cargo.lock
index 5c3809ea..ed8077ae 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -137,9 +137,9 @@ checksum = "a12916984aab3fa6e39d655a33e09c0071eb36d6ab3aea5c2d78551f1df6d952"
 
 [[package]]
 name = "cc"
-version = "1.1.3"
+version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18e2d530f35b40a84124146478cd16f34225306a8441998836466a2e2961c950"
+checksum = "324c74f2155653c90b04f25b2a47a8a631360cb908f92a772695f430c7e31052"
 
 [[package]]
 name = "cfg-if"
@@ -1423,7 +1423,7 @@ dependencies = [
 
 [[package]]
 name = "royalnet"
-version = "0.3.2"
+version = "0.4.0"
 dependencies = [
  "anyhow",
  "chrono",
@@ -1543,9 +1543,9 @@ checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
 [[package]]
 name = "security-framework"
-version = "2.11.0"
+version = "2.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c627723fd09706bacdb5cf41499e95098555af3c3c29d014dc3c458ef6be11c0"
+checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
 dependencies = [
  "bitflags 2.6.0",
  "core-foundation",
@@ -1556,9 +1556,9 @@ dependencies = [
 
 [[package]]
 name = "security-framework-sys"
-version = "2.11.0"
+version = "2.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "317936bbbd05227752583946b9e66d7ce3b489f84e11a94a510b4437fef407d7"
+checksum = "75da29fe9b9b08fe9d6b22b5b4bcbc75d8db3aa31e639aa56bb62e9d46bfceaf"
 dependencies = [
  "core-foundation-sys",
  "libc",
@@ -1625,15 +1625,6 @@ dependencies = [
  "syn 1.0.109",
 ]
 
-[[package]]
-name = "signal-hook-registry"
-version = "1.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9e9e0b4211b72e7b8b6e85c807d36c212bdb33ea8587f7569562a84df5465b1"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "slab"
 version = "0.4.9"
@@ -1877,9 +1868,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.38.0"
+version = "1.38.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba4f4a02a7a80d6f274636f0aa95c7e383b912d41fe721a31f29e29698585a4a"
+checksum = "eb2caba9f80616f438e09748d5acda951967e1ea58508ef53d9c6402485a46df"
 dependencies = [
  "backtrace",
  "bytes",
@@ -1887,7 +1878,6 @@ dependencies = [
  "mio",
  "num_cpus",
  "pin-project-lite",
- "signal-hook-registry",
  "socket2",
  "tokio-macros",
  "windows-sys 0.48.0",
diff --git a/Cargo.toml b/Cargo.toml
index cb9d8d0e..f05f28b2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "royalnet"
 description = "Fun software suite for the RYG community"
-version = "0.3.2"
+version = "0.4.0"
 edition = "2021"
 authors = [
     "Stefano Pigozzi <me@steffo.eu>"
@@ -26,23 +26,101 @@ exclude = [
     "/.env"
 ]
 
+#============#
+
 [dependencies]
-anyhow = "1.0.86"
-chrono = "0.4.38"
-diesel = { version = "2.2.1", features = ["postgres"] }
-log = { version = "0.4.22", features = ["release_max_level_debug"] }
-micronfig = "0.3.0"
-pretty_env_logger = "0.5.0"
-rand = { version = "0.8.5", features = ["small_rng"] }
-teloxide = { version = "0.12.2", features = ["ctrlc_handler", "native-tls", "macros"], default-features = false }
-tokio = { version = "1.38.0", features = ["macros", "rt-multi-thread", "time"] }
-parse_datetime = "0.6.0"
-regex = "1.10.5"
-once_cell = "1.19.0"
-reqwest = { version = "0.12.5", features = ["json"] }
-serde = { version = "1.0.204", features = ["derive"] }
-graphql_client = "0.14.0"
-thiserror = "1.0.62"
+
+[dependencies.anyhow]
+version = "1.0.86"
+
+[dependencies.thiserror]
+version = "1.0.62"
+
+[dependencies.tokio]
+version = "1.38.0"
+features = ["macros", "rt-multi-thread", "time"]
+
+[dependencies.log]
+version = "0.4.22"
+features = ["release_max_level_debug"]
+
+[dependencies.pretty_env_logger]
+version = "0.5.0"
+
+[dependencies.micronfig]
+version = "0.3.0"
+
+[dependencies.once_cell]
+version = "1.19.0"
+
+[dependencies.regex]
+version = "1.10.5"
+
+[dependencies.reqwest]
+version = "0.12.5"
+features = ["json"]
+
+[dependencies.serde]
+version = "1.0.204"
+features = ["derive"]
+
+[dependencies.diesel]
+version = "2.2.1"
+features = ["postgres"]
+optional = true
+
+[dependencies.teloxide]
+version = "0.12.2"
+default-features = false
+features = ["native-tls", "macros"]
+optional = true
+
+[dependencies.rand]
+version = "0.8.5"
+features = ["small_rng"]
+optional = true
+
+[dependencies.chrono]
+version = "0.4.38"
+optional = true
+
+[dependencies.parse_datetime]
+version = "0.6.0"
+optional = true
+
+[dependencies.graphql_client]
+version = "0.14.0"
+optional = true
+
+#============#
+
+[features]
+default = [
+    "interface_database",
+    "interface_stratz",
+    "service_brooch",
+    "service_telegram",
+]
+interface_database = [
+    "diesel"
+]
+interface_stratz = [
+    "graphql_client"
+]
+service_telegram = [
+    "interface_database",
+    "teloxide",
+    "rand",
+    "chrono",
+    "parse_datetime"
+]
+service_brooch = [
+    "interface_database",
+    "interface_stratz",
+    "graphql_client"
+]
+
+#============#
 
 [[bin]]
 name = "royalnet"
diff --git a/src/database/config.rs b/src/database/config.rs
deleted file mode 100644
index abccf732..00000000
--- a/src/database/config.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-use micronfig::config;
-
-config! {
-    DATABASE_URL,
-}
diff --git a/src/database/mod.rs b/src/database/mod.rs
deleted file mode 100644
index c82af032..00000000
--- a/src/database/mod.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-use diesel::{Connection, ConnectionResult, PgConnection};
-
-mod config;
-pub mod schema;
-pub mod models;
-
-pub fn connect() -> ConnectionResult<PgConnection> {
-	PgConnection::establish(config::DATABASE_URL())
-}
diff --git a/src/instance/config.rs b/src/instance/config.rs
new file mode 100644
index 00000000..a41d71eb
--- /dev/null
+++ b/src/instance/config.rs
@@ -0,0 +1,60 @@
+#![allow(unused_attributes, unused_qualifications, clippy::needless_pub_self)]
+
+
+#[cfg(feature = "service_telegram")]
+pub mod service_telegram {
+	use micronfig::config;
+
+	config! {
+		TELEGRAM_DATABASE_URL: String,
+		TELEGRAM_BOT_TOKEN: String,
+		TELEGRAM_NOTIFICATION_CHATID?: String > i64 -> crate::instance::config::ChatIdConversionHack -> teloxide::types::ChatId,
+	}
+}
+
+#[cfg(feature = "service_brooch")]
+pub mod brooch {
+	use micronfig::config;
+
+	#[allow(unused_qualifications)]
+	config! {
+		BROOCH_DATABASE_URL: String,
+		BROOCH_GRAPHQL_URL: String,
+		BROOCH_STRATZ_TOKEN: String,
+		BROOCH_TELEGRAM_BOT_TOKEN: String,
+		BROOCH_WATCHED_GUILD_ID: String > i64,
+		BROOCH_MIN_PLAYERS_TO_PROCESS: String > usize,
+		BROOCH_NOTIFICATION_CHAT_ID: String > i64 -> crate::instance::config::ChatIdConversionHack -> teloxide::types::ChatId,
+		BROOCH_MAX_IMP_WAIT_SECS: String > i64 -> crate::instance::config::TimeDeltaConversionHack => chrono::TimeDelta,
+	}
+}
+
+pub struct ChatIdConversionHack(i64);
+
+impl From<i64> for ChatIdConversionHack {
+	fn from(value: i64) -> Self {
+		Self(value)
+	}
+}
+
+impl From<ChatIdConversionHack> for teloxide::types::ChatId {
+	fn from(value: ChatIdConversionHack) -> Self {
+		Self(value.0)
+	}
+}
+
+pub struct TimeDeltaConversionHack(i64);
+
+impl From<i64> for TimeDeltaConversionHack {
+	fn from(value: i64) -> Self {
+		Self(value)
+	}
+}
+
+impl TryFrom<TimeDeltaConversionHack> for chrono::TimeDelta {
+	type Error = ();
+
+	fn try_from(value: TimeDeltaConversionHack) -> Result<Self, Self::Error> {
+		Self::new(value.0, 0).ok_or(())
+	}
+}
\ No newline at end of file
diff --git a/src/instance/mod.rs b/src/instance/mod.rs
new file mode 100644
index 00000000..9bd69394
--- /dev/null
+++ b/src/instance/mod.rs
@@ -0,0 +1,102 @@
+use std::future::Future;
+use crate::services::RoyalnetService;
+
+pub(self) mod config;
+
+pub struct RoyalnetInstance {
+	#[cfg(feature = "service_telegram")]
+	service_telegram: crate::services::telegram::TelegramService,
+
+	#[cfg(feature = "service_brooch")]
+	service_brooch: crate::services::brooch::BroochService,
+}
+
+impl RoyalnetInstance {
+	pub async fn new() -> Self {
+		let service_telegram = Self::setup_telegram_service().await;
+		let service_brooch = Self::setup_brooch_service();
+
+		Self {
+			service_telegram,
+			service_brooch,
+		}
+	}
+
+	pub async fn run(mut self) {
+		let future_telegram = async move {
+			Self::get_telegram_future(&mut self.service_telegram).await;
+		};
+		let future_brooch = async move {
+			Self::get_brooch_future(&mut self.service_brooch).await;
+		};
+
+		let task_telegram = tokio::spawn(future_telegram);
+		let task_brooch = tokio::spawn(future_brooch);
+
+		let _ = tokio::join!(
+			task_telegram,
+			task_brooch,
+		);
+	}
+
+	#[cfg(feature = "service_telegram")]
+	async fn setup_telegram_service() -> crate::services::telegram::TelegramService {
+		log::debug!("Setting up Telegram service...");
+
+		crate::services::telegram::TelegramService::new(
+			config::service_telegram::TELEGRAM_DATABASE_URL().clone(),
+			config::service_telegram::TELEGRAM_BOT_TOKEN().clone(),
+			config::service_telegram::TELEGRAM_NOTIFICATION_CHATID().clone(),
+		).await.expect("Unable to setup Telegram service.")
+	}
+
+	#[cfg(not(feature = "service_telegram"))]
+	async fn setup_telegram_service() -> () {
+		log::warn!("Telegram service is disabled.");
+
+		()
+	}
+
+	#[cfg(feature = "service_telegram")]
+	fn get_telegram_future(service: &mut crate::services::telegram::TelegramService) -> impl Future<Output = ()> + '_ {
+		service.run_loop()
+	}
+
+	#[cfg(not(feature = "service_telegram"))]
+	fn get_telegram_future(service: &mut crate::services::telegram::TelegramService) -> impl Future<Output = ()> + '_ {
+		async {}
+	}
+
+	#[cfg(feature = "service_brooch")]
+	fn setup_brooch_service() -> crate::services::brooch::BroochService {
+		log::debug!("Setting up Brooch service...");
+
+		crate::services::brooch::BroochService::new(
+			config::brooch::BROOCH_DATABASE_URL().clone(),
+			config::brooch::BROOCH_GRAPHQL_URL(),
+			config::brooch::BROOCH_STRATZ_TOKEN(),
+			config::brooch::BROOCH_WATCHED_GUILD_ID().clone(),
+			config::brooch::BROOCH_MIN_PLAYERS_TO_PROCESS().clone(),
+			config::brooch::BROOCH_TELEGRAM_BOT_TOKEN().clone(),
+			config::brooch::BROOCH_NOTIFICATION_CHAT_ID().clone(),
+			config::brooch::BROOCH_MAX_IMP_WAIT_SECS().clone(),
+		).expect("Unable to setup Brooch service.")
+	}
+
+	#[cfg(not(feature = "service_brooch"))]
+	fn setup_brooch_service() -> () {
+		log::warn!("Brooch service is disabled.");
+
+		()
+	}
+
+	#[cfg(feature = "service_brooch")]
+	fn get_brooch_future(service: &mut crate::services::brooch::BroochService) -> impl Future<Output = ()> + '_ {
+		service.run_loop()
+	}
+
+	#[cfg(not(feature = "service_brooch"))]
+	fn get_brooch_future(service: &mut crate::services::brooch::BroochService) -> impl Future<Output = ()> + '_ {
+		async {}
+	}
+}
\ No newline at end of file
diff --git a/src/interfaces/database/mod.rs b/src/interfaces/database/mod.rs
new file mode 100644
index 00000000..213108a6
--- /dev/null
+++ b/src/interfaces/database/mod.rs
@@ -0,0 +1,8 @@
+use diesel::{Connection, ConnectionResult, PgConnection};
+
+pub mod schema;
+pub mod models;
+
+pub fn connect(database_url: &str) -> ConnectionResult<PgConnection> {
+	PgConnection::establish(database_url)
+}
diff --git a/src/database/models.rs b/src/interfaces/database/models.rs
similarity index 97%
rename from src/database/models.rs
rename to src/interfaces/database/models.rs
index e31193fe..1ee3e06c 100644
--- a/src/database/models.rs
+++ b/src/interfaces/database/models.rs
@@ -44,6 +44,7 @@ pub struct SteamUser {
 }
 
 
+#[cfg(feature = "service_brooch")]
 #[derive(Debug, Clone, PartialEq, Identifiable, Queryable, Selectable, Insertable)]
 #[diesel(table_name = brooch_match)]
 #[diesel(check_for_backend(Pg))]
diff --git a/src/database/schema.rs b/src/interfaces/database/schema.rs
similarity index 95%
rename from src/database/schema.rs
rename to src/interfaces/database/schema.rs
index 1e38eec4..5dd61415 100644
--- a/src/database/schema.rs
+++ b/src/interfaces/database/schema.rs
@@ -1,5 +1,6 @@
 // @generated automatically by Diesel CLI.
 
+#[cfg(feature = "service_brooch")]
 diesel::table! {
     brooch_match (id) {
         id -> Int8,
diff --git a/src/interfaces/mod.rs b/src/interfaces/mod.rs
new file mode 100644
index 00000000..2c904602
--- /dev/null
+++ b/src/interfaces/mod.rs
@@ -0,0 +1,5 @@
+#[cfg(feature = "interface_database")]
+pub mod database;
+
+#[cfg(feature = "interface_stratz")]
+pub mod stratz;
diff --git a/src/interfaces/stratz/graphql.config.yml b/src/interfaces/stratz/graphql.config.yml
new file mode 100644
index 00000000..5f202155
--- /dev/null
+++ b/src/interfaces/stratz/graphql.config.yml
@@ -0,0 +1,2 @@
+schema: "schema.json"
+documents: "**/*.gql"
diff --git a/src/interfaces/stratz/guild_matches.rs b/src/interfaces/stratz/guild_matches.rs
new file mode 100644
index 00000000..4344a5a9
--- /dev/null
+++ b/src/interfaces/stratz/guild_matches.rs
@@ -0,0 +1,54 @@
+#![allow(unused_imports)]
+
+use graphql_client::GraphQLQuery;
+use reqwest::Url;
+pub use super::Short;
+pub use super::Long;
+pub use super::Byte;
+pub use super::QueryError as Error;
+
+#[derive(graphql_client::GraphQLQuery)]
+#[graphql(
+	schema_path = "src/interfaces/stratz/schema.json",
+	query_path = "src/interfaces/stratz/query_guild_matches.gql",
+	response_derives = "Debug, Clone"
+)]
+struct Query;
+
+pub type QueryResponse = graphql_client::Response<query::ResponseData>;
+pub type QueryResult = Result<QueryResponse, Error>;
+
+pub use query::LobbyTypeEnum as LobbyType;
+pub use query::GameModeEnumType as GameMode;
+pub use query::MatchLaneType as Lane;
+pub use query::MatchPlayerRoleType as Role;
+pub use query::QueryGuild as Guild;
+pub use query::QueryGuildMatches as Match;
+pub use query::QueryGuildMatchesPlayers as Player;
+pub use query::QueryGuildMatchesPlayersHero as Hero;
+pub use query::QueryGuildMatchesPlayersSteamAccount as Steam;
+pub use query::QueryGuildMatchesPlayersStatsMatchPlayerBuffEvent as Buff;
+
+pub async fn query(client: &reqwest::Client, url: Url, guild_id: i64) -> QueryResult {
+	log::debug!("Querying guild_matches of guild {guild_id}...");
+	log::trace!("Using client: {client:?}");
+	log::trace!("Using API at: {url:?}");
+
+	log::trace!("Configuring query variables...");
+	let vars = query::Variables { guild_id };
+
+	log::trace!("Building query...");
+	let body = Query::build_query(vars);
+
+	log::trace!("Making request...");
+	let response = client.post(url)
+		.json(&body)
+		.send()
+		.await
+		.map_err(|_| Error::Requesting)?
+		.json::<QueryResponse>()
+		.await
+		.map_err(|_| Error::Parsing)?;
+
+	Ok(response)
+}
diff --git a/src/interfaces/stratz/mod.rs b/src/interfaces/stratz/mod.rs
new file mode 100644
index 00000000..b804445a
--- /dev/null
+++ b/src/interfaces/stratz/mod.rs
@@ -0,0 +1,15 @@
+use thiserror::Error;
+
+pub type Short = i16;
+pub type Long = i64;
+pub type Byte = u8;
+
+#[derive(Debug, Clone, Error)]
+pub enum QueryError {
+	#[error("GraphQL request failed")]
+	Requesting,
+	#[error("GraphQL response parsing failed")]
+	Parsing,
+}
+
+pub mod guild_matches;
diff --git a/src/stratz/query_guild_matches.gql b/src/interfaces/stratz/query_guild_matches.gql
similarity index 89%
rename from src/stratz/query_guild_matches.gql
rename to src/interfaces/stratz/query_guild_matches.gql
index 0b4e2d31..1a3c9f48 100644
--- a/src/stratz/query_guild_matches.gql
+++ b/src/interfaces/stratz/query_guild_matches.gql
@@ -1,4 +1,4 @@
-query GuildMatchesQuery($guild_id: Int!) {
+query Query($guild_id: Int!) {
   guild(id: $guild_id) {
     id
     matches(take: 10) {
@@ -7,9 +7,9 @@ query GuildMatchesQuery($guild_id: Int!) {
       gameMode
       durationSeconds
       endDateTime
-      didRadiantWin
       players(steamAccountId: null) {
         isRadiant
+        isVictory
         imp
         kills
         deaths
diff --git a/src/stratz/schema.json b/src/interfaces/stratz/schema.json
similarity index 100%
rename from src/stratz/schema.json
rename to src/interfaces/stratz/schema.json
diff --git a/src/main.rs b/src/main.rs
index c835499a..57935906 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,41 +1,20 @@
-use anyhow::Result;
-use crate::services::RoyalnetService;
+use crate::instance::RoyalnetInstance;
 
-pub(crate) mod database;
-pub(crate) mod utils;
+mod instance;
+mod interfaces;
 mod services;
-mod stratz;
+pub(crate) mod utils;
 
 #[tokio::main]
-async fn main() -> Result<()> {
+async fn main() {
     // Logging setup
     pretty_env_logger::init();
     log::debug!("Logging initialized successfully!");
 
-    // Telegram setup
-    log::trace!("Setting up Telegram bot service...");
-    let telegram = services::telegram::BotService::from_config();
+    // Create instance
+    let instance = RoyalnetInstance::new().await;
 
-    // Brooch setup
-    log::trace!("Setting up Brooch service...");
-    let brooch = services::brooch::BroochService::from_config();
+    instance.run().await;
 
-    // Run all services concurrently
-    log::info!("Starting services...");
-    let result = tokio::try_join![
-        telegram.run(),
-        brooch.run(),
-    ];
-
-    // This should never happen, but just in case...
-    match result {
-        Err(error) => {
-            log::error!("A service has exited with an error, bailing out: {error:?}");
-            anyhow::bail!("A service has exited with an error.")
-        },
-        _ => {
-            log::error!("All service have exited successfully, bailing out...");
-            anyhow::bail!("All service have exited successfully.")
-        }
-    }
+    log::error!("No services configured.");
 }
diff --git a/src/services/brooch/config.rs b/src/services/brooch/config.rs
deleted file mode 100644
index b8aaa15f..00000000
--- a/src/services/brooch/config.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-use micronfig::config;
-
-config! {
-    BROOCH_TELEGRAM_BOT_TOKEN,
-	BROOCH_WATCHED_GUILD_ID: String > i64 -> crate::stratz::GuildId,
-	BROOCH_NOTIFICATION_CHAT_ID: String > i64 -> crate::utils::hacks::ChatIdConversionHack -> teloxide::types::ChatId
-}
\ No newline at end of file
diff --git a/src/services/brooch/mod.rs b/src/services/brooch/mod.rs
index 511e4b07..3c3fae01 100644
--- a/src/services/brooch/mod.rs
+++ b/src/services/brooch/mod.rs
@@ -1,141 +1,152 @@
 use std::cmp::PartialEq;
-use std::convert::Infallible;
-use anyhow::Result;
 use std::time::Duration;
 use anyhow::Context;
-use chrono::{TimeDelta, TimeZone};
+use chrono::{DateTime, TimeDelta, TimeZone, Utc};
 use diesel::PgConnection;
-use teloxide::Bot;
-use teloxide::payloads::SendMessageSetters;
-use teloxide::requests::Requester;
-use teloxide::types::ChatId;
+use reqwest::Url;
+use teloxide::prelude::*;
 use tokio::time::sleep;
-use crate::database;
+use crate::interfaces::database;
+use crate::interfaces::database::models::{BroochMatch};
 use crate::services::RoyalnetService;
-use crate::stratz::{GuildId, Match, Player, Role, Lane, query_guild_matches};
-use crate::stratz::guild_matches_query::{GameModeEnumType, LobbyTypeEnum};
-
-mod config;
+use crate::utils::result::AnyResult;
+use crate::interfaces::stratz::{Byte, guild_matches, Long, Short};
+use crate::interfaces::stratz::guild_matches::{GameMode, Lane, LobbyType, Match, Player, Role, Steam};
+use crate::utils::escape::EscapableInTelegramHTML;
 
+#[derive(Debug, Clone)]
 pub struct BroochService {
-	pub guild_id: GuildId,
-	pub chat_id: ChatId,
-	pub bot: Bot,
+	database_url: String,
+	graphql_url: Url,
+	watched_guild_id: i64,
+	min_players_to_process: usize,
+	telegram_bot: Bot,
+	notification_chat_id: ChatId,
+	max_imp_wait: TimeDelta,
 }
 
 impl BroochService {
-	const MAX_IMP_WAIT: TimeDelta = TimeDelta::minutes(60);
+	pub fn new(database_url: String, graphql_base_url: &str, stratz_token: &str, watched_guild_id: i64, min_players_to_process: usize, telegram_bot_token: String, notification_chat_id: ChatId, max_imp_wait: TimeDelta) -> AnyResult<Self> {
+		log::info!("Initializing a new Brooch service...");
 
-	pub fn from_config() -> Self {
-		Self {
-			guild_id: config::BROOCH_WATCHED_GUILD_ID().clone(),
-			chat_id: config::BROOCH_NOTIFICATION_CHAT_ID().clone(),
-			bot: Bot::new(config::BROOCH_TELEGRAM_BOT_TOKEN().clone()),
+		let mut graphql_url = Url::parse(&graphql_base_url)
+			.context("URL GraphQL non valido.")?;
+		{
+			let mut graphql_url_params = graphql_url.query_pairs_mut();
+			graphql_url_params.append_pair("jwt", stratz_token);
 		}
+
+		log::trace!("Using GraphQL API URL: {graphql_url:?}");
+
+		if min_players_to_process == 0 {
+			anyhow::bail!("min_players_to_progress devono essere almeno 1.");
+		}
+
+		log::trace!("Processing only matches with at least {min_players_to_process} players.");
+
+		let telegram_bot = Bot::new(telegram_bot_token);
+
+		log::trace!("Using bot: {telegram_bot:#?}");
+
+		log::trace!("Max IMP wait is: {max_imp_wait:?}");
+
+		Ok(
+			BroochService {
+				database_url,
+				graphql_url,
+				watched_guild_id,
+				min_players_to_process,
+				telegram_bot,
+				notification_chat_id,
+				max_imp_wait,
+			}
+		)
 	}
 
-	async fn iteration_request(&self) -> Result<()> {
-		let client = reqwest::Client::new();
+	fn create_http_client(&self) -> AnyResult<reqwest::Client> {
+		log::debug!("Creating HTTP client...");
 
-		let mut database = database::connect()
-			.context("Non è stato possibile connettersi al database RYG.")?;
+		reqwest::Client::builder()
+			.build()
+			.context("Impossibile creare un client HTTP appropriato a fare richieste all'API.")
+	}
 
-		let data = query_guild_matches(&client, &self.guild_id).await
-			.context("Non è stato possibile recuperare le ultime partite di Dota da STRATZ.")?;
+	fn create_postgres_connection(&self) -> AnyResult<PgConnection> {
+		log::debug!("Creating PostgreSQL connection...");
+
+		database::connect(&self.database_url)
+			.context("Non è stato possibile connettersi al database RYG.")
+	}
+
+	async fn query_guild_matches(&self, client: &reqwest::Client) -> AnyResult<guild_matches::QueryResponse> {
+		log::debug!("Querying for guild matches...");
+
+		guild_matches::query(client, self.graphql_url.clone(), self.watched_guild_id)
+			.await
+			.context("Non è stato possibile recuperare le ultime partite di Dota da STRATZ.")
+	}
+
+	fn process_guild_data(&self, data: guild_matches::QueryResponse) -> AnyResult<guild_matches::Guild> {
+		log::debug!("Processing guild data...");
 
 		let data = data.data
 			.context("La richiesta è riuscita, ma la risposta ricevuta da STRATZ era vuota.")?;
 
-		let data = data.guild
+		let guild = data.guild
 			.context("La richiesta è riuscita, ma non sono state ricevute gilde da STRATZ.")?;
 
-		let guild_id: GuildId = data.id.clone()
-			.context("La richiesta è riuscita, ma non è stato ricevuto l'ID della gilda da STRATZ.")?
-			.into();
+		let guild_id: i64 = guild.id
+			.context("La richiesta è riuscita, ma non è stato ricevuto l'ID della gilda da STRATZ.")?;
 
-		if guild_id != self.guild_id {
+		log::trace!("Guild id is: {guild_id}");
+
+		if guild_id != self.watched_guild_id {
 			anyhow::bail!("La richiesta è riuscita, ma STRATZ ha risposto con le informazioni della gilda sbagliata.");
 		}
 
-		let mut matches = data.matches
-			.context("La richiesta è riuscita, ma non sono state ricevute informazioni sulle partite della gilda da STRATZ.")?;
+		log::trace!("Guild id matches watched guild.");
+
+		Ok(guild)
+	}
+
+	fn process_matches_data(&self, guild: guild_matches::Guild) -> AnyResult<Vec<Match>> {
+		log::debug!("Processing matches data...");
+
+		let mut matches = guild.matches
+			.context("La richiesta è riuscita, ma non sono state ricevute informazioni sulle partite della gilda da STRATZ.")?
+			.into_iter()
+			.filter_map(|o| o)
+			.collect::<Vec<Match>>();
+
+		log::trace!("Received {} matches.", matches.len());
+
+		log::trace!("Sorting matches by datetime...");
 
 		// Sort matches chronologically
 		matches.sort_unstable_by_key(|o| o
-			.to_owned()
-			.map(|o| o
-				.end_date_time
-				.unwrap_or(0)
-			)
+			.end_date_time
 			.unwrap_or(0)
 		);
 
-		let mut results: Vec<Result<(i64, Option<String>)>> = vec![];
+		log::trace!("Sorted matches by datetime!");
 
-		for r#match in matches.iter().filter_map(|o| o.to_owned()) {
-			results.push(
-				self.iteration_match(&mut database, r#match).await
-			);
-		}
-
-		let results: Vec<(i64, String)> = results
-			.into_iter()
-			.inspect(|f| match f {
-				Err(e) => log::error!("Error while processing match: {e}"),
-				Ok((match_id, None)) => log::debug!("Skipping: {match_id}"),
-				_ => {}
-			})
-			.filter_map(|f| f.ok())
-			.filter_map(|f| f.1.map(|s| (f.0, s)))
-			.collect();
-
-		for result in results {
-			let (match_id, text) = result;
-
-			let msg = self.bot.send_message(self.chat_id, text)
-				.parse_mode(teloxide::types::ParseMode::Html)
-				.disable_notification(true)
-				.disable_web_page_preview(true)
-				.await;
-
-			if let Err(e) = msg {
-				log::error!("Error while sending notification for match {match_id}: {e}");
-				continue
-			}
-
-			{
-				use diesel::prelude::*;
-				use crate::database::schema::brooch_match::dsl::*;
-				use crate::database::models::{BroochMatch};
-
-				let match_royalnet = BroochMatch { id: result.0 };
-
-				let result = diesel::insert_into(brooch_match)
-					.values(&match_royalnet)
-					.returning(BroochMatch::as_returning())
-					.get_result(&mut database);
-
-				if let Err(e) = result {
-					log::error!("Error while inserting in database match {match_id}: {e}");
-					continue
-				}
-
-				log::trace!("Inserted in database match {match_id}!");
-			}
-		}
-
-		Ok(())
+		Ok(matches)
 	}
 
-	async fn iteration_match(&self, database: &mut PgConnection, r#match: Match) -> Result<(i64, Option<String>)> {
-		let match_id = r#match.id
-			.context("La richiesta è riuscita, ma non è stato ricevuto da STRATZ l'ID della partita.")?;
+	fn get_match_id(&self, r#match: &Match) -> AnyResult<Long> {
+		log::trace!("Getting match id...");
+
+		r#match.id.clone()
+			.context("La richiesta è riuscita, ma non è stato ricevuto da STRATZ l'ID della partita.")
+	}
+
+	fn get_database_match(&self, database: &mut PgConnection, match_id: Long) -> AnyResult<Option<BroochMatch>> {
+		log::trace!("Getting match {match_id} from the database...");
 
 		let match_royalnet = {
 			use diesel::prelude::*;
 			use diesel::{ExpressionMethods, QueryDsl};
-			use crate::database::schema::brooch_match::dsl::*;
-			use crate::database::models::{BroochMatch};
+			use crate::interfaces::database::schema::brooch_match::dsl::*;
 
 			brooch_match
 				.filter(id.eq(match_id))
@@ -145,22 +156,136 @@ impl BroochService {
 				.context("Non è stato possibile recuperare la partita restituita da STRATZ dal database RYG.")?
 		};
 
-		if match_royalnet.is_some() {
-			log::trace!("Match result was already sent, skipping...");
-			return Ok((match_id, None));
-		};
+		Ok(match_royalnet)
+	}
+
+	fn should_process_match_exists(&self, database: &mut PgConnection, match_id: Long) -> AnyResult<bool> {
+		log::trace!("Determining whether {match_id} should be processed...");
+
+		Ok(
+			self.get_database_match(database, match_id)?
+				.is_none()
+		)
+	}
+
+	fn get_match_datetime(&self, r#match: &Match) -> AnyResult<DateTime<Utc>> {
+		log::trace!("Getting match datetime...");
 
 		let match_date = r#match.end_date_time
 			.context("Non è stato ricevuto da STRATZ il momento di termine della partita.")?;
 
-		let match_date = chrono::Utc.timestamp_opt(match_date, 0)
+		log::trace!("Converting match datetime to DateTime<Utc> object...");
+
+		Utc.timestamp_opt(match_date, 0)
 			.earliest()
-			.context("È stato ricevuto da STRATZ un momento di termine della partita non valido.")?;
+			.context("È stato ricevuto da STRATZ un momento di termine della partita non valido.")
+	}
 
-		let now = chrono::Utc::now();
+	fn get_match_timedelta(&self, datetime: &DateTime<Utc>) -> TimeDelta {
+		log::trace!("Getting current time...");
 
-		// How much time has passed since the match has ended?
-		let match_offset = match_date - now;
+		let now = Utc::now();
+
+		log::trace!("Getting match timedelta...");
+
+		now - *datetime
+	}
+
+	fn get_match_type(&self, r#match: &Match) -> AnyResult<LobbyType> {
+		log::trace!("Getting match type...");
+
+		r#match.lobby_type.clone()
+			.context("Non è stato ricevuta da STRATZ il tipo della partita.")
+	}
+
+	fn stringify_type(&self, r#type: LobbyType) -> String {
+		use LobbyType::*;
+
+		log::trace!("Stringifying match type: {:?}", r#type);
+
+		match r#type {
+			UNRANKED => String::from("Normale"),
+			PRACTICE => String::from("Torneo"),
+			TOURNAMENT => String::from("The International"),
+			TUTORIAL => String::from("Tutorial"),
+			COOP_VS_BOTS => String::from("Co-op"),
+			TEAM_MATCH => String::from("Scontro di Clan"),
+			SOLO_QUEUE => String::from("Coda solitaria"),
+			RANKED => String::from("Classificata"),
+			SOLO_MID => String::from("Duello"),
+			BATTLE_CUP => String::from("Battle Cup"),
+			EVENT => String::from("Evento"),
+			DIRE_TIDE => String::from("Diretide"),
+			Other(t) => t.clone(),
+		}
+	}
+
+	fn get_match_mode(&self, r#match: &Match) -> AnyResult<GameMode> {
+		log::trace!("Getting match mode...");
+
+		r#match.game_mode.clone()
+			.context("Non è stata ricevuta da STRATZ la modalità della partita.")
+	}
+
+	fn stringify_mode(&self, mode: GameMode) -> String {
+		use GameMode::*;
+
+		log::trace!("Stringifying match mode: {:?}", mode);
+
+		match mode {
+			NONE => String::from("Sandbox"),
+			ALL_PICK => String::from("All Pick"),
+			CAPTAINS_MODE => String::from("Captains Mode"),
+			RANDOM_DRAFT => String::from("Random Draft"),
+			SINGLE_DRAFT => String::from("Single Draft"),
+			ALL_RANDOM => String::from("All Random"),
+			INTRO => String::from("Tutorial"),
+			THE_DIRETIDE => String::from("Diretide"),
+			REVERSE_CAPTAINS_MODE => String::from("Reverse Captains"),
+			THE_GREEVILING => String::from("The Greeviling"),
+			TUTORIAL => String::from("Tutorial"),
+			MID_ONLY => String::from("Mid Only"),
+			LEAST_PLAYED => String::from("Least Played"),
+			NEW_PLAYER_POOL => String::from("New Player"),
+			COMPENDIUM_MATCHMAKING => String::from("Compendium"),
+			CUSTOM => String::from("Arcade"),
+			CAPTAINS_DRAFT => String::from("Captains Draft"),
+			BALANCED_DRAFT => String::from("Balanced Draft"),
+			ABILITY_DRAFT => String::from("Ability Draft"),
+			EVENT => String::from("Evento"),
+			ALL_RANDOM_DEATH_MATCH => String::from("All Random Deathmatch"),
+			SOLO_MID => String::from("Mid Duel"),
+			ALL_PICK_RANKED => String::from("All Draft"),
+			TURBO => String::from("Turbo"),
+			MUTATION => String::from("Mutation"),
+			UNKNOWN => String::from("Unknown"),
+			Other(t) => t.clone(),
+		}
+	}
+
+	fn stringify_duration(&self, duration: TimeDelta) -> String {
+		let minutes = duration.num_minutes();
+		let seconds = duration.num_seconds() % 60;
+
+		format!("{minutes:02}:{seconds:02}")
+	}
+
+	fn get_match_duration(&self, r#match: &Match) -> AnyResult<TimeDelta> {
+		log::trace!("Getting match duration...");
+
+		let secs = r#match.duration_seconds
+			.context("Non è stata ricevuta da STRATZ la durata della partita.")?;
+
+		log::trace!("Getting match duration timedelta...");
+
+		let delta = TimeDelta::new(secs, 0)
+			.context("Non è stato possibile rappresentare la durata della partita ricevuta da STRATZ.")?;
+
+		Ok(delta)
+	}
+
+	fn get_match_players(&self, r#match: Match) -> AnyResult<Vec<Player>> {
+		log::debug!("Getting match players...");
 
 		let mut players: Vec<Player> = r#match.players
 			.context("Non è stato ricevuto da STRATZ l'elenco dei giocatori della partita.")?
@@ -168,294 +293,462 @@ impl BroochService {
 			.filter_map(|o| o.to_owned())
 			.collect();
 
-		if players.len() < 1 {
-			anyhow::bail!("È stato ricevuto da STRATZ un elenco vuoto di giocatori nella partita.");
-		}
+		log::trace!("Sorting match players...");
 
-		let match_side: MatchSide = 'side: {
-			let players_teams = {
-				let players_teams_inner: Vec<Option<bool>> = players.iter()
-					.map(|o| o.is_radiant)
-					.collect();
-
-				for player_team in players_teams_inner.iter() {
-					if player_team.is_none() {
-						player_team.context("Non è stata ricevuta da STRATZ la squadra di almeno un giocatore nella partita.")?;
-					}
-				}
-
-				let players_teams_inner: Vec<bool> = players_teams_inner
-					.iter()
-					.map(|o| o.unwrap())
-					.collect();
-
-				players_teams_inner
-			};
-
-			let mut predicted_team = None;
-
-			for player_team in players_teams {
-				if predicted_team.is_none() {
-					predicted_team = Some(player_team)
-				}
-				else if predicted_team.unwrap() != player_team {
-					break 'side MatchSide::Both;
-				}
-			}
-
-			match predicted_team.unwrap() {
-				true => MatchSide::Radiant,
-				false => MatchSide::Dire,
-			}
-		};
-
-		// Is IMP available?
-		let imp_is_ready = players.iter()
-			.map(|o| o.imp)
-			.map(|o| o.is_some())
-			.all(|o| o);
-
-		// Have we waited too long for IMP to be calculated?
-		let imp_wait_too_long = match_offset > Self::MAX_IMP_WAIT;
-
-		if !(imp_is_ready || imp_wait_too_long) {
-			log::trace!("IMP is not ready, waiting a bit more...");
-			// Let's wait some more.
-			return Ok((match_id, None));
-		}
-
-		let match_radiant_win = r#match.did_radiant_win
-			.context("Non è stato ricevuto da STRATZ il vincitore della partita.")?;
-
-		let match_outcome = MatchOutcome::from(&match_side, match_radiant_win);
-
-		let match_outcome_emoji = match_outcome.emoji();
-
-		let match_type = r#match.lobby_type.clone()
-			.context("Non è stato ricevuta da STRATZ il tipo della partita.")?;
-
-		let match_type_str = match match_type {
-			LobbyTypeEnum::UNRANKED => "Normale",
-			LobbyTypeEnum::PRACTICE => "Torneo",
-			LobbyTypeEnum::TOURNAMENT => "The International",
-			LobbyTypeEnum::TUTORIAL => "Tutorial",
-			LobbyTypeEnum::COOP_VS_BOTS => "Co-op",
-			LobbyTypeEnum::TEAM_MATCH => "Scontro di Clan",
-			LobbyTypeEnum::SOLO_QUEUE => "Coda solitaria",
-			LobbyTypeEnum::RANKED => "Classificata",
-			LobbyTypeEnum::SOLO_MID => "Duello",
-			LobbyTypeEnum::BATTLE_CUP => "Battle Cup",
-			LobbyTypeEnum::EVENT => "Evento",
-			LobbyTypeEnum::DIRE_TIDE => "Diretide",
-			LobbyTypeEnum::Other(t) => anyhow::bail!("Il tipo di partita ricevuto da STRATZ è sconosciuto: {}", t)
-		};
-
-		let match_mode = r#match.game_mode.clone()
-			.context("Non è stata ricevuta da STRATZ la modalità della partita.")?;
-
-		let match_mode_str = match match_mode {
-			GameModeEnumType::NONE => "Sandbox",
-			GameModeEnumType::ALL_PICK => "All Pick",
-			GameModeEnumType::CAPTAINS_MODE => "Captains Mode",
-			GameModeEnumType::RANDOM_DRAFT => "Random Draft",
-			GameModeEnumType::SINGLE_DRAFT => "Single Draft",
-			GameModeEnumType::ALL_RANDOM => "All Random",
-			GameModeEnumType::INTRO => "Tutorial",
-			GameModeEnumType::THE_DIRETIDE => "Diretide",
-			GameModeEnumType::REVERSE_CAPTAINS_MODE => "Reverse Captains",
-			GameModeEnumType::THE_GREEVILING => "The Greeviling",
-			GameModeEnumType::TUTORIAL => "Tutorial",
-			GameModeEnumType::MID_ONLY => "Mid Only",
-			GameModeEnumType::LEAST_PLAYED => "Least Played",
-			GameModeEnumType::NEW_PLAYER_POOL => "New Player",
-			GameModeEnumType::COMPENDIUM_MATCHMAKING => "Compendium",
-			GameModeEnumType::CUSTOM => "Arcade",
-			GameModeEnumType::CAPTAINS_DRAFT => "Captains Draft",
-			GameModeEnumType::BALANCED_DRAFT => "Balanced Draft",
-			GameModeEnumType::ABILITY_DRAFT => "Ability Draft",
-			GameModeEnumType::EVENT => "Evento",
-			GameModeEnumType::ALL_RANDOM_DEATH_MATCH => "All Random Deathmatch",
-			GameModeEnumType::SOLO_MID => "Mid Duel",
-			GameModeEnumType::ALL_PICK_RANKED => "All Draft",
-			GameModeEnumType::TURBO => "Turbo",
-			GameModeEnumType::MUTATION => "Mutation",
-			GameModeEnumType::UNKNOWN => anyhow::bail!("La modalità di partita ricevuto da STRATZ è sconosciuta."),
-			GameModeEnumType::Other(t) => anyhow::bail!("Il tipo di partita ricevuto da STRATZ è sconosciuta: {}", t)
-		};
-
-		let match_duration = r#match.duration_seconds
-			.context("Non è stata ricevuta da STRATZ la durata della partita.")?;
-
-		// Let's begin writing the message
-		let mut text = format!(
-			"{match_outcome_emoji} <a href=\"https://stratz.com/matches/{match_id}\"><b><u>Partita #{match_id}</u></b></a>\n\
-			<b>{match_type_str}</b> · {match_mode_str} · <i>{match_duration}</i>\n\
-			\n\
-			",
-		);
-
-		// Let's sort players by team...
 		players.sort_unstable_by_key(|o| match o.is_radiant.unwrap() {
 			true => 1,
 			false => 2,
 		});
 
-		for player in players {
-			let player_steam = player.steam_account.clone()
-				.context("Non è stato ricevuto da STRATZ l'account Steam di almeno uno dei giocatori della partita.")?;
+		log::trace!("Sorted match players!");
 
-			let player_steam_id = player_steam.id
-				.context("Non è stato ricevuto da STRATZ lo SteamID di almeno uno dei giocatori della partita.")?;
+		Ok(players)
+	}
 
-			let player_steam_name = player_steam.name
-				.context("Non è stato ricevuto da STRATZ il display name di almeno uno dei giocatori della partita.")?;
+	fn should_process_match_players(&self, players: &[Player]) -> bool {
+		let players_len = players.len();
 
-			let player_hero = player.hero.clone()
-				.context("Non è stato ricevuto da STRATZ l'eroe giocato da almeno uno dei giocatori della partita.")?;
+		log::trace!("Determining whether {players_len} are enough for the match to be processed...");
 
-			let player_hero_name = player_hero.display_name
-				.context("Non è stato ricevuto da STRATZ il nome dell'eroe giocato da almeno uno dei giocatori della partita.")?;
+		players_len >= self.min_players_to_process
+	}
 
+	fn should_process_match_imp(&self, players: &[Player], timedelta: &TimeDelta) -> bool {
+		log::trace!("Determining whether IMP is available for all players...");
 
-			let player_telegram = {
-				use diesel::prelude::*;
-				use diesel::{ExpressionMethods, QueryDsl};
-				use crate::database::schema::steam::dsl::*;
-				use crate::database::schema::users::dsl::*;
-				use crate::database::schema::telegram::dsl::*;
-				use crate::database::models::TelegramUser;
+		let imp_available_for_everyone = players.iter()
+			.map(|o| o.imp)
+			.map(|o| o.is_some())
+			.all(|o| o);
 
-				steam
-					.filter(steam_id.eq(player_steam_id))
-					.inner_join(users
-						.inner_join(telegram)
-					)
-					.select(TelegramUser::as_select())
-					.get_result(database)
-					.optional()
-					.ok()
-					.flatten()
-			};
+		log::trace!("Determining whether enough time has passed for IMP to be ignored...");
 
-			let player_telegram_id = player_telegram
-				.map(|t| t.telegram_id);
+		let imp_waited_too_long = *timedelta > self.max_imp_wait;
 
-			text.push_str(
-				&match player_telegram_id {
-					Some(player_telegram_id) => format!(
-						"<a href=\"tg://user?id={player_telegram_id}\"><b>{player_steam_name}</b></a> ({player_hero_name})\n"
-					),
-					None => format!(
-						"<b>{player_steam_name}</b> ({player_hero_name})\n"
-					),
-				});
+		return imp_available_for_everyone || imp_waited_too_long
+	}
 
-			let player_role: Option<Role> = player.role.clone();
-			let player_lane: Option<Lane> = player.lane.clone();
+	fn get_match_side(&self, players: &[Player]) -> AnyResult<MatchSide> {
+		use MatchSide::*;
 
-			if let Some(player_role) = player_role {
-				if let Some(player_lane) = player_lane {
-					text.push_str(
-						match (player_role, player_lane) {
-							(Role::CORE, Lane::SAFE_LANE) => "— 1️⃣ Safe Carry\n",
-							(Role::CORE, Lane::MID_LANE) => "— 2️⃣ Mid Carry\n",
-							(Role::CORE, Lane::OFF_LANE) => "— 3️⃣ Off Carry\n",
-							(Role::LIGHT_SUPPORT, _) => "— 4️⃣ Soft Support\n",
-							(Role::HARD_SUPPORT, _) => "— 5️⃣ Hard Support\n",
-							(_, Lane::JUNGLE) => "— 🔼 Jungle\n",
-							(_, Lane::ROAMING) => "— 🔀 Roaming\n",
-							_ => "",
-						}
-					);
+		log::debug!("Getting match side...");
+
+		let mut side = None;
+
+		for player in players.iter() {
+			side = match (side, player.is_radiant) {
+				(_, None) => {
+					anyhow::bail!("Non è stata ricevuta da STRATZ la squadra di almeno uno dei giocatori.")
+				},
+				(None, Some(true)) => {
+					Some(Radiant)
+				},
+				(None, Some(false)) => {
+					Some(Dire)
+				},
+				(Some(Radiant), Some(true)) |
+				(Some(Dire), Some(false)) => {
+					side
+				},
+				(Some(Radiant), Some(false)) |
+				(Some(Dire), Some(true)) => {
+					Some(Both)
+				},
+				(Some(Both), _) => {
+					break
 				}
 			}
-
-			let player_imp = player.imp;
-
-			let player_imp_emoji = 'emoji: {
-				if player_imp.is_none() {
-					break 'emoji ""
-				}
-				let player_imp = player_imp.unwrap();
-				if player_imp < -50 {
-					"🔲"
-				} else if player_imp < -25 {
-					"⬛️"
-				} else if player_imp < -18 {
-					"◼️"
-				} else if player_imp < -9 {
-					"◾️"
-				} else if player_imp < 0 {
-					"▪️"
-				} else if player_imp <= 9 {
-					"▫️"
-				} else if player_imp <= 18 {
-					"◽️"
-				} else if player_imp <= 25 {
-					"◻️"
-				} else if player_imp <= 50 {
-					"⬜️"
-				} else {
-					"🔳"
-				}
-			};
-
-			let player_kills = player.kills
-				.context("La richiesta è riuscita, ma non è stato ricevuto da STRATZ il numero di uccisioni di almeno uno dei giocatori delle partite.")?;
-
-			let player_deaths = player.deaths
-				.context("La richiesta è riuscita, ma non è stato ricevuto da STRATZ il numero di morti di almeno uno dei giocatori delle partite.")?;
-
-			let player_assists = player.assists
-				.context("La richiesta è riuscita, ma non è stato ricevuto da STRATZ il numero di aiuti di almeno uno dei giocatori delle partite.")?;
-
-			text.push_str(&match player_imp {
-				Some(player_imp) => format!(
-					"— {player_imp_emoji} {player_imp} IMP ({player_kills}/{player_deaths}/{player_assists})\n"
-				),
-				None => format!(
-					"— ❔ {player_kills}/{player_deaths}/{player_assists}\n"
-				),
-			});
-
-			if match_outcome == MatchOutcome::Clash {
-				let player_is_radiant = player.is_radiant.unwrap();
-
-				text.push_str(match (match_radiant_win, player_is_radiant) {
-					(true, true) => "🟢 Vittoria!\n",
-					(false, false) => "🟢 Vittoria!\n",
-					(true, false) => "🟥 Sconfitta...\n",
-					(false, true) => "🟥 Sconfitta...\n",
-				})
-			}
-
-			let player_stats = player.stats.clone()
-				.context("La richiesta è riuscita, ma non sono state ricevute da STRATZ le statistiche di almeno uno dei giocatori delle partite.")?;
-
-			let player_buffs = player_stats.match_player_buff_event.clone()
-				.unwrap_or_default();
-
-			for _buff in player_buffs.iter().filter_map(|s| s.to_owned()) {
-				// TODO: Let's do this another time.
-			}
-
-			text.push_str("\n")
 		}
 
-		Ok((match_id, Some(text)))
+		let side = side.unwrap();
+
+		log::trace!("Match side is: {side:?}");
+
+		Ok(side)
+	}
+	
+	fn get_match_outcome(&self, players: &[Player]) -> AnyResult<MatchOutcome> {
+		use MatchOutcome::*;
+
+		log::debug!("Getting match outcome...");
+
+		let mut outcome = None;
+
+		for player in players.iter() {
+			outcome = match (outcome, player.is_victory) {
+				(_, None) => {
+					anyhow::bail!("Non è stata ricevuta da STRATZ la squadra di almeno uno dei giocatori.")
+				},
+				(None, Some(true)) => {
+					Some(Victory)
+				},
+				(None, Some(false)) => {
+					Some(Defeat)
+				},
+				(Some(Victory), Some(true)) |
+				(Some(Defeat), Some(false)) => {
+					outcome
+				},
+				(Some(Victory), Some(false)) |
+				(Some(Defeat), Some(true)) => {
+					Some(Clash)
+				},
+				(Some(Clash), _) => {
+					break
+				}
+			}
+		}
+
+		let outcome = outcome.unwrap();
+
+		log::trace!("Match outcome is: {outcome:?}");
+
+		Ok(outcome)
+	}
+
+	fn get_player_steam(&self, player: &Player) -> AnyResult<Steam> {
+		log::trace!("Getting player's Steam account...");
+
+		player.steam_account.clone()
+			.context("Non è stato ricevuto da STRATZ l'account Steam di almeno uno dei giocatori della partita.")
+	}
+
+	fn get_player_name(&self, steam: &Steam) -> AnyResult<String> {
+		log::trace!("Getting player's Steam name...");
+
+		steam.name.clone()
+			.context("Non è stato ricevuto da STRATZ il display name di almeno uno dei giocatori della partita.")
+	}
+
+	fn get_player_telegram_id(&self, database: &mut PgConnection, player_steam: Steam) -> AnyResult<Option<i64>> {
+		use diesel::prelude::*;
+		use diesel::{ExpressionMethods, QueryDsl};
+		use crate::interfaces::database::schema::{steam, users, telegram};
+		use crate::interfaces::database::models::TelegramUser;
+
+		log::trace!("Getting player's Steam name...");
+
+		let player_steam_id = player_steam.id.clone()
+			.context("Non è stato ricevuto da STRATZ lo SteamID di almeno uno dei giocatori della partita.")?;
+
+		log::trace!("Computing the two possible SteamIDs...");
+
+		let player_steam_id_y0 = 0x_0110_0001_0000_0000 + player_steam_id;
+
+		log::trace!("SteamID Y0 is: {player_steam_id_y0}");
+
+		let player_steam_id_y1 = 0x_0110_0001_0000_0001 + player_steam_id;
+
+		log::trace!("SteamID Y1 is: {player_steam_id_y1}");
+
+		Ok(
+			steam::table
+				.inner_join(
+					users::table.on(
+						steam::user_id.eq(users::id)
+					)
+				)
+				.inner_join(
+					telegram::table.on(
+						users::id.eq(telegram::user_id)
+					)
+				)
+				.filter(
+					steam::steam_id.eq(player_steam_id_y0)
+				)
+				.or_filter(
+					steam::steam_id.eq(player_steam_id_y1)
+				)
+				.select(TelegramUser::as_select())
+				.get_result(database)
+				.optional()
+				.context("Non è stato possibile connettersi al database RYG.")?
+				.map(|t| t.telegram_id)
+		)
+	}
+
+	fn get_player_hero_name(&self, player: &Player) -> AnyResult<String> {
+		log::trace!("Getting player's hero name...");
+
+		player.hero.clone()
+			.context("Non è stato ricevuto da STRATZ l'eroe giocato da almeno uno dei giocatori della partita.")?
+			.display_name
+			.context("Non è stato ricevuto da STRATZ il nome dell'eroe giocato da almeno uno dei giocatori della partita.")
+	}
+
+	fn get_player_outcome(&self, player: &Player) -> AnyResult<MatchOutcome> {
+		use MatchOutcome::*;
+
+		log::trace!("Getting player's match outcome...");
+
+		let is_victory = &player.is_victory
+			.context("Non è stato ricevuto da STRATZ il risultato della partita per almeno uno dei giocatori.")?;
+
+		Ok(
+			match is_victory {
+				true => Victory,
+				false => Defeat,
+			}
+		)
+	}
+
+	fn emojify_outcome(&self, outcome: MatchOutcome) -> &'static str {
+		use MatchOutcome::*;
+
+		log::trace!("Emojifying match outcome...");
+
+		match outcome {
+			Victory => "🟩",
+			Defeat => "🔴",
+			Clash => "💛",
+		}
+	}
+
+	fn stringify_outcome(&self, outcome: MatchOutcome) -> &'static str {
+		use MatchOutcome::*;
+
+		log::trace!("Stringifying match outcome...");
+
+		match outcome {
+			Victory => "Vittoria!",
+			Defeat => "Sconfitta...",
+			Clash => "Derby",
+		}
+	}
+
+	fn stringify_role_lane(&self, role: Role, lane: Lane) -> &'static str {
+		use Role::*;
+		use Lane::*;
+
+		log::trace!("Stringifying role and lane...");
+
+		match (role, lane) {
+			(         CORE, SAFE_LANE) => "1️⃣ Safe Carry",
+			(         CORE,  MID_LANE) => "2️⃣ Mid Carry",
+			(         CORE,  OFF_LANE) => "3️⃣ Off Tank",
+			(            _,   ROAMING) => "🔀 Roaming",
+			(            _,    JUNGLE) => "⏫ Jungle",
+			(LIGHT_SUPPORT,         _) => "4️⃣ Soft Support",
+			( HARD_SUPPORT,         _) => "5️⃣ Hard Support",
+			(            _,         _) => "🆕 Sconosciuto",
+		}
+	}
+
+	fn emojify_imp(&self, imp: Short) -> &'static str {
+		log::trace!("Emojifying IMP...");
+
+		match imp {
+			Short::MIN..=-50 => "🟧",
+			-49..=-25 => "🔶",
+			-24..=-1 => "🔸",
+			0..=24 => "🔹",
+			25..=49 => "🔷️",
+			50..=Short::MAX => "🟦",
+		}
+	}
+
+	fn emojify_kills_deaths_assists(&self, kills: Byte, deaths: Byte, assists: Byte) -> &'static str {
+		log::trace!("Emojifying KDA...");
+
+		let kills = kills as i16;
+		let deaths = deaths as i16;
+		let assists = assists as i16;
+
+		let kda_score = kills + (assists / 2) - deaths;
+
+		match kda_score {
+			i16::MIN..=-1 => "➖",
+			0..=i16::MAX => "➕",
+		}
+	}
+
+	fn stringify_player(&self, database: &mut PgConnection, player: Player, show_outcome: bool) -> AnyResult<String> {
+		log::debug!("Stringifying player...");
+		log::trace!("Showing outcome: {show_outcome:?}");
+
+		let steam = self.get_player_steam(&player)?;
+		let name = self.get_player_name(&steam)?;
+		let telegram_id = self.get_player_telegram_id(database, steam)?;
+		let hero_name = self.get_player_hero_name(&player)?;
+		let outcome = self.get_player_outcome(&player)?;
+
+		let role = player.role.clone();
+		let lane = player.lane.clone();
+		let imp = player.imp;
+
+		let kills = player.kills;
+		let deaths = player.deaths;
+		let assists = player.assists;
+
+		// TODO: Buffs
+
+		let mut lines = Vec::<String>::new();
+
+		match telegram_id {
+			None => lines.push(format!(
+				"<u><b>{}</b> ({})</u>",
+				name.escape_telegram_html(),
+				hero_name.escape_telegram_html(),
+			)),
+			Some(telegram_id) => lines.push(format!(
+				"<u><a href=\"tg://user?id={telegram_id}\"><b>{}</b></a> ({})</u>",
+				name.escape_telegram_html(),
+				hero_name.escape_telegram_html(),
+			)),
+		}
+
+		if show_outcome {
+			lines.push(format!(
+				"— {}", self.stringify_outcome(outcome)
+			))
+		}
+
+		if let (Some(role), Some(lane)) = (role, lane) {
+			lines.push(format!(
+				"— {}", self.stringify_role_lane(role, lane)
+			))
+		}
+
+		if let (Some(kills), Some(deaths), Some(assists)) = (kills, deaths, assists) {
+			lines.push(format!(
+				"— {} <b>{kills} K</b> / {deaths} D / {assists} A", self.emojify_kills_deaths_assists(kills, deaths, assists)
+			))
+		}
+
+		if let Some(imp) = imp {
+			lines.push(format!(
+				"— {} <b>{imp}</b> IMP", self.emojify_imp(imp)
+			))
+		}
+
+		Ok(lines.join("\n"))
+	}
+
+	fn stringify_match(&self, database: &mut PgConnection, r#match: Match) -> AnyResult<(Long, Option<String>)> {
+		log::debug!("Stringifying match...");
+
+		let match_id = self.get_match_id(&r#match)?;
+
+		if !self.should_process_match_exists(database, match_id)? {
+			log::trace!("Skipping match, already parsed.");
+			return Ok((match_id, None))
+		}
+
+		let datetime = self.get_match_datetime(&r#match)?;
+		let timedelta = self.get_match_timedelta(&datetime);
+
+		let r#type = self.get_match_type(&r#match)?;
+		let mode = self.get_match_mode(&r#match)?;
+		let duration = self.get_match_duration(&r#match)?;
+
+		let players = self.get_match_players(r#match)?;
+
+		if !self.should_process_match_players(&players) {
+			log::trace!("Skipping match, not enough players.");
+			return Ok((match_id, None))
+		}
+		
+		if !self.should_process_match_imp(&players, &timedelta) {
+			log::trace!("Skipping match, IMP is not ready.");
+			return Ok((match_id, None))
+		}
+
+		let _side = self.get_match_side(&players)?;
+		let outcome = self.get_match_outcome(&players)?;
+
+		let mut lines = Vec::<String>::new();
+
+		lines.push(format!(
+			"{} <u><b>{}</b></u>",
+			self.emojify_outcome(outcome),
+			self.stringify_outcome(outcome),
+		));
+
+		lines.push(format!(
+			"<b>{}</b> · {} · <i>{}</i>",
+			self.stringify_type(r#type),
+			self.stringify_mode(mode),
+			self.stringify_duration(duration),
+		));
+
+		lines.push("".to_string());
+
+		for player in players.into_iter() {
+			let string = self.stringify_player(database, player, outcome == MatchOutcome::Clash)?;
+			lines.push(string);
+			lines.push("".to_string());
+		}
+
+		lines.push(format!(
+			"Partita <code>{match_id}</code> · <a href=\"https://stratz.com/matches/{match_id}\">Apri su STRATZ</a>"
+		));
+
+		Ok((match_id, Some(lines.join("\n"))))
+	}
+
+	async fn send_notification(&self, text: &str) -> AnyResult<Message> {
+		log::debug!("Sending notification...");
+
+		self.telegram_bot.send_message(self.notification_chat_id, text)
+			.parse_mode(teloxide::types::ParseMode::Html)
+			.disable_notification(true)
+			.disable_web_page_preview(true)
+			.await
+			.context("Impossibile inviare la notifica di una partita.")
+	}
+
+	fn flag_match_id(&self, database: &mut PgConnection, match_id: Long) -> AnyResult<BroochMatch> {
+		use diesel::prelude::*;
+		use crate::interfaces::database::schema::brooch_match::dsl::*;
+		use crate::interfaces::database::models::{BroochMatch};
+
+		log::debug!("Flagging as parsed match id: {match_id}");
+
+		let match_royalnet = BroochMatch { id: match_id };
+
+		diesel::insert_into(brooch_match)
+			.values(&match_royalnet)
+			.returning(BroochMatch::as_returning())
+			.get_result(database)
+			.context("Impossibile marcare la partita come processata nel database RYG.")
+	}
+
+	async fn iteration(&self) -> AnyResult<()> {
+		log::debug!("Now running an iteration of brooch!");
+
+		let client = self.create_http_client()?;
+		let mut database = self.create_postgres_connection()?;
+
+		let data = self.query_guild_matches(&client).await?;
+
+		let guild = self.process_guild_data(data)?;
+		let matches = self.process_matches_data(guild)?;
+
+		let results = matches
+			.into_iter()
+			.map(|r#match| self.stringify_match(&mut database, r#match))
+			.collect::<Vec<AnyResult<(Long, Option<String>)>>>();
+
+		for result in results {
+			let (match_id, message) = result?;
+
+			if let Some(message) = message {
+				self.send_notification(&message).await?;
+				self.flag_match_id(&mut database, match_id)?;
+			}
+		}
+		
+		Ok(())
 	}
 }
 
 impl RoyalnetService for BroochService {
-	#[allow(unreachable_code)]
-	async fn run(self) -> Result<Infallible> {
+	async fn run(&mut self) -> AnyResult<()> {
 		loop {
-			self.iteration_request().await?;
+			self.iteration().await?;
 
 			sleep(Duration::new(60 * 15, 0)).await;
 		}
-
-		anyhow::bail!("Brooch service has exited.")
 	}
 }
 
@@ -472,23 +765,3 @@ pub enum MatchOutcome {
 	Defeat,
 	Clash,
 }
-
-impl MatchOutcome {
-	pub fn from(side: &MatchSide, radiant_win: bool) -> Self {
-		match (side, radiant_win) {
-			(MatchSide::Both, _) => Self::Clash,
-			(MatchSide::Radiant, true) => Self::Victory,
-			(MatchSide::Radiant, false) => Self::Defeat,
-			(MatchSide::Dire, true) => Self::Defeat,
-			(MatchSide::Dire, false) => Self::Victory,
-		}
-	}
-
-	pub fn emoji(&self) -> &'static str {
-		match self {
-			MatchOutcome::Victory => "🟢",
-			MatchOutcome::Defeat => "🟥",
-			MatchOutcome::Clash => "🔶",
-		}
-	}
-}
diff --git a/src/services/mod.rs b/src/services/mod.rs
index 42b82f1f..746ad073 100644
--- a/src/services/mod.rs
+++ b/src/services/mod.rs
@@ -1,9 +1,40 @@
-use std::convert::Infallible;
-use anyhow::Result;
-
-pub mod telegram;
-pub mod brooch;
+use std::time::Duration;
+use tokio::time::sleep;
+use crate::utils::result::AnyResult;
 
 pub trait RoyalnetService {
-	async fn run(self) -> Result<Infallible>;
+	async fn run(&mut self) -> AnyResult<()>;
+
+	async fn run_loop(&mut self) {
+		let mut backoff = Duration::new(1, 0);
+
+		loop {
+			let result = self.run().await;
+
+			match result {
+				Err(e) => {
+					log::error!("Service exited with error: {e:?}.")
+				},
+				_ => {
+					log::debug!("Service exited successfully!")
+				},
+			}
+
+			let backoff_secs = backoff.as_secs();
+
+			log::debug!("Backing off for {backoff_secs} seconds before restarting...");
+			sleep(backoff).await;
+
+			log::trace!("Doubling backoff value...");
+			backoff *= 2;
+
+			log::trace!("Backoff value is now {backoff_secs} seconds.");
+		}
+	}
 }
+
+#[cfg(feature = "service_telegram")]
+pub mod telegram;
+
+#[cfg(feature = "service_brooch")]
+pub mod brooch;
diff --git a/src/services/telegram/commands/mod.rs b/src/services/telegram/commands/mod.rs
index 1f8db1dc..577c040a 100644
--- a/src/services/telegram/commands/mod.rs
+++ b/src/services/telegram/commands/mod.rs
@@ -7,6 +7,7 @@ use teloxide::payloads::SendMessageSetters;
 use teloxide::requests::Requester;
 use teloxide::types::{ChatId, Message, MessageId};
 use teloxide::utils::command::BotCommands;
+use crate::services::telegram::deps::interface_database::DatabaseInterface;
 
 mod start;
 mod fortune;
@@ -58,7 +59,7 @@ impl Command {
 		Ok(())
 	}
 
-	pub async fn handle(self, bot: Bot, message: Message) -> CommandResult {
+	pub async fn handle(self, bot: Bot, message: Message, database: &DatabaseInterface) -> CommandResult {
 		log::trace!("Handling command: {self:?}");
 
 		let result = match self {
@@ -69,7 +70,7 @@ impl Command {
 			},
 			Command::Fortune => fortune::handler(&bot, &message).await,
 			Command::Echo(text) => echo::handler(&bot, &message, &text).await,
-			Command::WhoAmI => whoami::handler(&bot, &message).await,
+			Command::WhoAmI => whoami::handler(&bot, &message, &database).await,
 			Command::Answer(_) => answer::handler(&bot, &message).await,
 			Command::Reminder(args) => reminder::handler(&bot, &message, args).await,
 			Command::Dog => dog::handler(&bot, &message).await,
diff --git a/src/services/telegram/commands/reminder.rs b/src/services/telegram/commands/reminder.rs
index c5a62db9..1f333cb9 100644
--- a/src/services/telegram/commands/reminder.rs
+++ b/src/services/telegram/commands/reminder.rs
@@ -7,7 +7,7 @@ use teloxide::types::{Message, ParseMode};
 use parse_datetime::parse_datetime_at_date;
 use once_cell::sync::Lazy;
 use regex::Regex;
-use crate::services::telegram::escape::EscapableInTelegramHTML;
+use crate::utils::escape::EscapableInTelegramHTML;
 use super::{CommandResult};
 
 
diff --git a/src/services/telegram/commands/roll.rs b/src/services/telegram/commands/roll.rs
index e270728a..4a0f12c3 100644
--- a/src/services/telegram/commands/roll.rs
+++ b/src/services/telegram/commands/roll.rs
@@ -7,39 +7,43 @@ use crate::services::telegram::commands::{CommandResult};
 use regex::Regex;
 
 
-
 pub async fn handler(bot: &Bot, message: &Message, roll: &str) -> CommandResult {
     let mut rng = rand::rngs::SmallRng::from_entropy();
+
     if rng.gen_range(1..1001) == 1 {
         let _reply = bot
-		.send_message(message.chat.id, "🎶 Roll? Rick roll! https://www.youtube.com/watch?v=dQw4w9WgXcQ")
-		.reply_to_message_id(message.id)
-		.await
-		.context("Non è stato possibile inviare la risposta.")?;
+			.send_message(message.chat.id, "🎶 Roll? Rick roll! https://www.youtube.com/watch?v=dQw4w9WgXcQ")
+			.reply_to_message_id(message.id)
+			.await
+			.context("Non è stato possibile inviare la risposta.")?;
 
 	    return Ok(())
     }
 
     let re = Regex::new(r#"(?P<qty>[0-9]*)?d(?P<die>[0-9]+)(?P<modifier>[+-]?[0-9]*)?"#).unwrap();
-let qty = captures.name("qty") // Prova a vedere se c'è il gruppo "qty"
-		.map(|m| m.as_str())  // `map`: se c'è, trasforma il suo contenuto in stringa
-		.map(|m| m.parse::<u32>())  // `map`: se c'è, trasforma la stringa in un u32
-		.map(|m| m.context("La quantità di dadi da lanciare deve essere un numero intero positivo diverso da 0.")?)  // `map`: se c'è, ma il parsing ha dato errore, restituiscilo e fai terminare la funzione qui
-		.unwrap_or(1);  // `unwrap_or`: se c'è, restituisci il valore, altrimenti, defaulta a 1
 
-	let die = captures.name("die") // Prova a vedere se c'è il gruppo "die"
-		.unwrap()  // `unwrap`: possiamo asserire che il gruppo "die" sia sempre presente se la regex ha matchato
-		.as_str()  // trasforma il suo contenuto in stringa
-		.parse::<u32>()  // trasforma la stringa in un u32
-		.context("La dimensione del dado da lanciare deve essere un numero intero positivo.")?;  // se il parsing ha dato errore, restituiscilo e fai terminare la funzione qui
+	let captures = re.captures(roll)
+		.context("Sintassi dei dadi non corretta.")?;
+	
+	let qty = captures.name("qty")
+		.map(|m| m.as_str())
+		.map(|m| m.parse::<u32>())
+		.unwrap_or(Ok(1))
+		.context("La quantità di dadi da lanciare deve essere un numero intero positivo diverso da 0.")?;
 
-	let modifier = captures.name("modifier") // Prova a vedere se c'è il gruppo "modifier"
-		.map(|m| m.as_str())  // `map`: se c'è, trasforma il suo contenuto in stringa
-		.map(|m| m.parse::<i32>())  // `map`: se c'è, trasforma la stringa in un i32
-		.map(|m| m.context("Il modificatore dei dadi lanciati deve essere un numero intero.")?)  // `map`: se c'è, ma il parsing ha dato errore, restituiscilo e fai terminare la funzione qui
-		.unwrap_or(0);  // `unwrap_or`: se c'è, restituisci il valore, altrimenti, defaulta a 0
+	let die = captures.name("die")
+		.unwrap()
+		.as_str()
+		.parse::<u32>()
+		.context("La dimensione del dado da lanciare deve essere un numero intero positivo.")?;
 
-    if die <= 0  {
+	let modifier = captures.name("modifier")
+		.map(|m| m.as_str())
+		.map(|m| m.parse::<i32>())
+		.unwrap_or(Ok(0))
+		.context("Il modificatore dei dadi lanciati deve essere un numero intero.")?;
+
+    if die == 0  {
 		anyhow::bail!("Non è stato specificato nessun dado.")
     }
 
@@ -47,37 +51,32 @@ let qty = captures.name("qty") // Prova a vedere se c'è il gruppo "qty"
         anyhow::bail!("La quantità di dadi specificata deve essere un intero positivo.")
     }
 
-
-
-    let mut nums_rolled = Vec::<i32>::new();
+    let mut nums_rolled = Vec::<u32>::new();
     for _ in 0..qty {
-        nums_rolled.push(rng.gen_range(1..die+1));
+        nums_rolled.push(
+			rng.gen_range(1..=die)
+		);
     }
-    
-    
-    let mut answer = String::from("🎲 [");
-    for i in 0..qty {
-        if i > 0 { answer.push_str("+")}
-        answer.push_str( &nums_rolled[i].to_string() );
-    }
-    answer.push_str("] ");
-
+	
+	let roll_string = nums_rolled
+		.iter()
+		.map(|n| n.to_string())
+		.collect::<Vec<String>>()
+		.join("\n");
+        
+    let mut answer = format!("🎲 [{roll_string}]");
+		
     if modifier != 0 {
-        if modifier > 0 {
-            answer.push_str("+");
-        }
-        answer.push_str( &modifier.to_string() );
+		answer.push_str(&format!("{modifier:+}"))
     }
 
     answer.push_str(" = ");
 
-    let mut sum: i32 = nums_rolled.iter().sum();
-    sum = sum + modifier;
-
-
-    answer.push_str( &sum.to_string() );
-
-
+    let sum: u32 = nums_rolled.iter().sum();
+    let sum: i32 = sum as i32 + modifier;
+	
+    answer.push_str(&sum.to_string());
+	
 	let _reply = bot
 		.send_message(message.chat.id, answer)
 		.reply_to_message_id(message.id)
diff --git a/src/services/telegram/commands/whoami.rs b/src/services/telegram/commands/whoami.rs
index a9fbc1a0..11f6148e 100644
--- a/src/services/telegram/commands/whoami.rs
+++ b/src/services/telegram/commands/whoami.rs
@@ -3,23 +3,23 @@ use teloxide::Bot;
 use teloxide::payloads::SendMessageSetters;
 use teloxide::requests::Requester;
 use teloxide::types::{Message, ParseMode};
-use crate::database::models::{RoyalnetUser};
-use crate::services::telegram::escape::EscapableInTelegramHTML;
+use crate::interfaces::database::models::{RoyalnetUser};
+use crate::services::telegram::deps::interface_database::DatabaseInterface;
+use crate::utils::escape::EscapableInTelegramHTML;
 use super::{CommandResult};
 
-pub async fn handler(bot: &Bot, message: &Message) -> CommandResult {
+pub async fn handler(bot: &Bot, message: &Message, database: &DatabaseInterface) -> CommandResult {
 	let author = message.from()
 		.context("Non è stato possibile determinare chi ha inviato questo comando.")?;
 
-	let mut database = crate::database::connect().
-		context("Non è stato possibile connettersi al database RYG.")?;
+	let mut database = database.connect()?;
 
 	let royalnet_user: RoyalnetUser = {
 		use diesel::prelude::*;
 		use diesel::{ExpressionMethods, QueryDsl};
-		use crate::database::schema::telegram::dsl::*;
-		use crate::database::schema::users::dsl::*;
-		use crate::database::models::RoyalnetUser;
+		use crate::interfaces::database::schema::telegram::dsl::*;
+		use crate::interfaces::database::schema::users::dsl::*;
+		use crate::interfaces::database::models::RoyalnetUser;
 
 		telegram
 			.filter(telegram_id.eq::<i64>(
diff --git a/src/services/telegram/config.rs b/src/services/telegram/config.rs
deleted file mode 100644
index 2ed10efa..00000000
--- a/src/services/telegram/config.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-use micronfig::config;
-
-// Everything ok, RustRover?
-config! {
-    TELEGRAM_BOT_TOKEN,
-    TELEGRAM_NOTIFICATION_CHATID?: String > i64 -> crate::utils::hacks::ChatIdConversionHack -> teloxide::types::ChatId,
-}
diff --git a/src/services/telegram/deps/interface_database.rs b/src/services/telegram/deps/interface_database.rs
new file mode 100644
index 00000000..099e4964
--- /dev/null
+++ b/src/services/telegram/deps/interface_database.rs
@@ -0,0 +1,19 @@
+use anyhow::Context;
+use diesel::PgConnection;
+use crate::utils::result::AnyResult;
+
+#[derive(Debug, Clone)]
+pub struct DatabaseInterface {
+	database_url: String,
+}
+
+impl DatabaseInterface {
+	pub fn new(database_url: String) -> Self {
+		Self { database_url }
+	}
+
+	pub fn connect(&self) -> AnyResult<PgConnection> {
+		crate::interfaces::database::connect(&self.database_url)
+			.context("Impossibile connettersi al database RYG")
+	}
+}
diff --git a/src/services/telegram/deps/mod.rs b/src/services/telegram/deps/mod.rs
new file mode 100644
index 00000000..ae88ce84
--- /dev/null
+++ b/src/services/telegram/deps/mod.rs
@@ -0,0 +1,2 @@
+#[cfg(feature = "interface_database")]
+pub mod interface_database;
diff --git a/src/services/telegram/mod.rs b/src/services/telegram/mod.rs
index 87aefd83..871c84ac 100644
--- a/src/services/telegram/mod.rs
+++ b/src/services/telegram/mod.rs
@@ -1,113 +1,164 @@
-use std::convert::Infallible;
-use teloxide::{Bot, dptree};
-use anyhow::{Context, Error, Result};
+use anyhow::Context;
+use teloxide::prelude::*;
+use teloxide::types::{Me, ParseMode};
 use regex::Regex;
-use teloxide::dispatching::{DefaultKey, Dispatcher, HandlerExt, UpdateFilterExt};
+use teloxide::dispatching::DefaultKey;
 use teloxide::dptree::entry;
-use teloxide::payloads::SendMessageSetters;
-use teloxide::requests::Requester;
-use teloxide::types::{Me, Message, ParseMode, Update};
-use crate::services::telegram::escape::EscapableInTelegramHTML;
+use crate::services::telegram::commands::Command;
+use crate::services::telegram::deps::interface_database::DatabaseInterface;
+use crate::utils::result::{AnyError, AnyResult};
+use crate::utils::escape::EscapableInTelegramHTML;
 use super::RoyalnetService;
 
-#[allow(clippy::needless_pub_self)]
-pub(self) mod config;
 mod commands;
-pub(self) mod escape;
 
-pub struct BotService {
-	pub bot: Bot
+pub(self) mod deps;
+
+#[derive(Debug, Clone)]
+pub struct TelegramService {
+	database_url: String,
+	bot: Bot,
+	me: Me,
+	notification_chat_id: Option<ChatId>,
 }
 
-impl BotService {
-	pub fn from_config() -> Self {
-		Self {
-			bot: Bot::new(config::TELEGRAM_BOT_TOKEN())
-		}
+impl TelegramService {
+	pub async fn new(database_url: String, token: String, notification_chat_id: Option<ChatId>) -> AnyResult<Self> {
+		log::info!("Initializing a new Telegram service...");
+
+		let bot = Bot::new(token);
+
+		log::trace!("Using bot: {bot:#?}");
+
+		let me = Self::get_me(&bot)
+			.await?;
+
+		log::trace!("Using self details: {me:#?}");
+
+		let service = Self {
+			database_url,
+			bot,
+			me,
+			notification_chat_id
+		};
+
+		log::trace!("Created service: {service:#?}");
+
+		Ok(service)
 	}
 
-	async fn send_start_notification(&mut self, me: &Me) -> Result<()> {
-		let chat_id = config::TELEGRAM_NOTIFICATION_CHATID()
-			.context("Variabile d'ambiente TELEGRAM_NOTIFICATION_CHATID mancante.")?;
+	async fn get_me(bot: &Bot) -> AnyResult<Me> {
+		log::debug!("Getting self details...");
+		bot.get_me().await
+			.context("Recupero dettagli sul bot non riuscito.")
+	}
 
-		let version = crate::utils::version::VERSION;
-		let username = &me.username.as_ref().unwrap();
-		let id = &me.user.id;
+	async fn send_start_notification(&self) -> AnyResult<Message> {
+		log::debug!("Sending start notification...");
+
+		let notification_chat_id = self.notification_chat_id
+			.context("La chat di notifica non è abilitata.")?;
+
+		let version = crate::utils::version::VERSION
+			.escape_telegram_html();
+
+		let username = self.me.username
+			.as_ref()
+			.unwrap()
+			.escape_telegram_html();
+
+		let id = self.me.user.id
+			.to_string()
+			.escape_telegram_html();
 
 		let text = format!(
 			"💠 <b>Servizio Telegram avviato</b>\n\
-				\n\
-				Royalnet <a href='https://github.com/RYGhub/royalnet/releases/tag/v{}'>v{}</a>\n\
-				\n\
-				@{} [<code>{}</code>]",
-			version.escape_telegram_html(),
-			version.escape_telegram_html(),
-			username.escape_telegram_html(),
-			id.to_string().escape_telegram_html(),
+			\n\
+			Royalnet <a href='https://github.com/RYGhub/royalnet/releases/tag/v{version}'>v{version}</a>\n\
+			\n\
+			@{username} [<code>{id}</code>]"
 		);
 
-		self.bot.send_message(chat_id, text)
+		log::trace!("Sending start notification message...");
+		let msg = self.bot.send_message(notification_chat_id, text)
 			.parse_mode(ParseMode::Html)
 			.await
 			.context("Invio della notifica di avvio non riuscito.")?;
 
-		Ok(())
+		log::trace!("Successfully sent start notification message!");
+		Ok(msg)
+	}
+
+	async fn set_commands(&mut self) -> AnyResult<()> {
+		log::debug!("Setting self commands...");
+		Command::set_commands(&mut self.bot).await
+			.context("Aggiornamento dei comandi del bot non riuscito.")
+	}
+
+	fn dispatcher(&mut self) -> Dispatcher<Bot, AnyError, DefaultKey> {
+		log::debug!("Building dispatcher...");
+
+		let bot_name = self.me.user.username.as_ref().unwrap();
+		log::trace!("Bot username is: @{bot_name:?}");
+
+		log::trace!("Determining pseudo-command regex...");
+		let regex = Regex::new(&format!(r"^/[a-z0-9_]+(?:@{bot_name})?(?:\s+.*)?$")).unwrap();
+		log::trace!("Pseudo-command regex is: {regex:?}");
+
+		let database = DatabaseInterface::new(self.database_url.clone());
+
+		log::trace!("Building dispatcher...");
+		Dispatcher::builder(
+			self.bot.clone(),
+			// Only process message updates
+			Update::filter_message()
+				// Pseudo-commands
+				.branch(entry()
+					// Only process commands matching the pseudo-command regex
+					.filter(move |message: Message| -> bool {
+						message
+							.text()
+							.is_some_and(|text| regex.is_match(text))
+					})
+					// Commands
+					.branch(
+						entry()
+							// Only process commands matching a valid command, and parse their arguments
+							.filter_command::<Command>()
+							// Delegate handling
+							.endpoint(Command::handle)
+					)
+					// No valid command was found
+					.endpoint(commands::unknown_command)
+				)
+		)
+			.dependencies(
+				dptree::deps![
+					database
+				]
+			)
+			.build()
+	}
+
+	async fn dispatch(&mut self) -> AnyResult<()> {
+		log::debug!("Starting Telegram dispatcher...");
+		self.dispatcher().dispatch().await;
+
+		anyhow::bail!("Telegram dispatcher has exited unexpectedly.")
 	}
 }
 
-impl RoyalnetService for BotService {
-	async fn run(mut self) -> Result<Infallible> {
+impl RoyalnetService for TelegramService {
+	async fn run(&mut self) -> AnyResult<()> {
 		log::info!("Starting Telegram service...");
 
-		log::debug!("Getting bot information...");
-		let me = self.bot.get_me().await
-			.context("Failed to get information about self")?;
+		let _ = self.set_commands()
+			.await;
 
-		log::debug!("Setting bot commands...");
-		match commands::Command::set_commands(&mut self.bot).await {
-			Err(e) => log::warn!("Failed to set bot commands: {e}"),
-			_ => log::trace!("Bot commands set successfully!"),
-		}
+		let _ = self.send_start_notification()
+			.await;
 
-		log::debug!("Sending start notification...");
-		match self.send_start_notification(&me).await {
-			Err(e) => log::warn!("Failed to send start notification: {e}"),
-			_ => log::trace!("Start notification sent successfully!"),
-		}
-
-		log::debug!("Starting Telegram dispatcher...");
-		dispatcher(self.bot, me).dispatch().await;
-
-		log::error!("Telegram dispatcher has exited, bailing out...");
-		anyhow::bail!("Telegram dispatcher has exited.")
+		self.dispatch()
+			.await
 	}
 }
-
-fn dispatcher(bot: Bot, me: Me) -> Dispatcher<Bot, Error, DefaultKey> {
-	let bot_name = me.user.username.unwrap();
-	log::trace!("Bot name is: {bot_name:?}");
-
-	let regex = Regex::new(&format!(r"^/[a-z0-9_]+(?:@{bot_name})?(?:\s+.*)?$")).unwrap();
-	log::trace!("Pseudo-command regex is: {regex:?}");
-
-	log::trace!("Building dispatcher...");
-	Dispatcher::builder(
-		bot,
-		Update::filter_message()
-			.branch(entry()
-				.filter(move |message: Message| -> bool {
-					message.text().is_some_and(|text| regex.is_match(text))
-				})
-				.branch(
-					entry()
-						.filter_command::<commands::Command>()
-						.endpoint(commands::Command::handle)
-				)
-				.endpoint(commands::unknown_command)
-			)
-	)
-		.dependencies(
-			dptree::deps![]  // No deps needed at the moment.
-		)
-		.build()
-}
diff --git a/src/stratz/config.rs b/src/stratz/config.rs
deleted file mode 100644
index ea92526d..00000000
--- a/src/stratz/config.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-use micronfig::config;
-
-config! {
-	STRATZ_TOKEN: String,
-}
diff --git a/src/stratz/mod.rs b/src/stratz/mod.rs
deleted file mode 100644
index 27795dfa..00000000
--- a/src/stratz/mod.rs
+++ /dev/null
@@ -1,86 +0,0 @@
-use graphql_client::GraphQLQuery;
-use reqwest::Client;
-use thiserror::Error;
-
-pub(self) mod config;
-
-const STRATZ_GRAPHQL_API_URL: &str = "https://api.stratz.com/graphql";
-
-// Bind these weird types used in the STRATZ API
-type Short = i16;
-type Long = i64;
-type Byte = u8;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct GuildId(pub i64);
-
-impl From<i64> for GuildId {
-	fn from(value: i64) -> Self {
-		Self(value)
-	}
-}
-
-#[derive(GraphQLQuery)]
-#[graphql(schema_path="src/stratz/schema.json", query_path="src/stratz/query_guild_matches.gql", response_derives="Debug, Clone")]
-pub struct GuildMatchesQuery;
-
-
-#[derive(Debug, Clone, Error)]
-pub enum QueryError {
-	#[error("GraphQL request failed")]
-	Requesting,
-	#[error("GraphQL response parsing failed")]
-	Parsing,
-}
-
-type GuildMatchesQueryResponse = graphql_client::Response<guild_matches_query::ResponseData>;
-
-#[allow(unused_imports)]
-pub use guild_matches_query::LobbyTypeEnum as LobbyType;
-#[allow(unused_imports)]
-pub use guild_matches_query::GameModeEnumType as GameMode;
-#[allow(unused_imports)]
-pub use guild_matches_query::GuildMatchesQueryGuild as Guild;
-#[allow(unused_imports)]
-pub use guild_matches_query::GuildMatchesQueryGuildMatches as Match;
-#[allow(unused_imports)]
-pub use guild_matches_query::GuildMatchesQueryGuildMatchesPlayers as Player;
-#[allow(unused_imports)]
-pub use guild_matches_query::GuildMatchesQueryGuildMatchesPlayersHero as Hero;
-#[allow(unused_imports)]
-pub use guild_matches_query::GuildMatchesQueryGuildMatchesPlayersSteamAccount as Steam;
-#[allow(unused_imports)]
-pub use guild_matches_query::MatchPlayerRoleType as Role;
-#[allow(unused_imports)]
-pub use guild_matches_query::MatchLaneType as Lane;
-#[allow(unused_imports)]
-pub use guild_matches_query::GuildMatchesQueryGuildMatchesPlayersStatsMatchPlayerBuffEvent as Buff;
-
-
-/// Get the latest 10 matches of a certain Dota 2 guild.
-pub async fn query_guild_matches(client: &Client, guild_id: &GuildId) -> Result<GuildMatchesQueryResponse, QueryError> {
-	log::debug!("Querying guild matches with {client:?} for {guild_id:?}...");
-
-	log::trace!("Configuring query variables...");
-	let params = guild_matches_query::Variables {
-		guild_id: guild_id.0,
-	};
-
-	log::trace!("Building query...");
-	let body = GuildMatchesQuery::build_query(params);
-
-	log::trace!("Building API URL...");
-	let url = format!("{}?jwt={}", STRATZ_GRAPHQL_API_URL, config::STRATZ_TOKEN());
-	log::trace!("STRATZ API URL is: {url:?}");
-
-	log::trace!("Making request...");
-	let response = client.post(url)
-		.json(&body)
-		.send().await
-		.map_err(|_| QueryError::Requesting)?
-		.json::<GuildMatchesQueryResponse>().await
-		.map_err(|_| QueryError::Parsing)?;
-
-	log::trace!("Request successful!");
-	Ok(response)
-}
\ No newline at end of file
diff --git a/src/services/telegram/escape.rs b/src/utils/escape.rs
similarity index 100%
rename from src/services/telegram/escape.rs
rename to src/utils/escape.rs
diff --git a/src/utils/hacks.rs b/src/utils/hacks.rs
deleted file mode 100644
index 13a8b70f..00000000
--- a/src/utils/hacks.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-use teloxide::types::ChatId;
-
-pub struct ChatIdConversionHack(i64);
-
-impl From<i64> for ChatIdConversionHack {
-	fn from(value: i64) -> Self {
-		Self(value)
-	}
-}
-
-impl From<ChatIdConversionHack> for ChatId {
-	fn from(value: ChatIdConversionHack) -> Self {
-		Self(value.0)
-	}
-}
-
-impl From<ChatIdConversionHack> for i64 {
-	fn from(value: ChatIdConversionHack) -> Self {
-		value.0
-	}
-}
-
-impl From<ChatId> for ChatIdConversionHack {
-	fn from(value: ChatId) -> Self {
-		Self(value.0)
-	}
-}
\ No newline at end of file
diff --git a/src/utils/mod.rs b/src/utils/mod.rs
index e1ec57ca..8ccf528c 100644
--- a/src/utils/mod.rs
+++ b/src/utils/mod.rs
@@ -1,3 +1,4 @@
 pub mod time;
 pub mod version;
-pub mod hacks;
+pub mod result;
+pub mod escape;
diff --git a/src/utils/result.rs b/src/utils/result.rs
new file mode 100644
index 00000000..dbdfc6b4
--- /dev/null
+++ b/src/utils/result.rs
@@ -0,0 +1,2 @@
+pub use anyhow::Result as AnyResult;
+pub use anyhow::Error as AnyError;