From 77a2f3bfae84619e6f82903f0cfbfe03d70da206 Mon Sep 17 00:00:00 2001
From: Tristan Vermeesch <titivermeesch@gmail.com>
Date: Tue, 18 Nov 2025 22:10:16 +0100
Subject: [PATCH] feat: new scheduling engine

---
 build.gradle                                  |   4 +-
 docs/docs/configuration/adhoc-commands.md     | 139 ++++++
 docs/docs/configuration/conditions.md         |   4 +-
 docs/docs/configuration/index.md              |   1 +
 docs/docs/developers/index.md                 |   5 +-
 docs/docs/extensions/index.md                 |   2 +-
 docs/docs/faq.md                              |   2 +-
 docs/docs/intro.md                            |  22 +-
 docs/docs/jargon.md                           |  21 +-
 docs/docs/jsonschema.md                       |  26 +-
 docs/docs/miscellaneous.md                    |   4 +
 docs/docs/placeholders.md                     |   2 +-
 docs/docs/storage/index.md                    |   4 +-
 java17-build.gradle                           |   4 +-
 java21-build.gradle                           |   4 +-
 .../playbosswar/com/CommandTimerPlugin.java   |  20 +-
 .../playbosswar/com/commands/MainCommand.java |  66 +++
 .../java/me/playbosswar/com/gui/MainMenu.java |   8 +
 .../com/gui/tasks/EditTaskMenu.java           |  15 +-
 .../gui/tasks/ScheduledExecutionsMenu.java    | 199 +++++++++
 .../gui/tasks/general/GeneralLimitsMenu.java  |   1 +
 .../general/TextInputConversationPrompt.java  |  46 --
 .../com/gui/tasks/scheduler/EditHourMenu.java |   2 +
 .../gui/tasks/scheduler/EditIntervalMenu.java |  11 +
 .../tasks/scheduler/EditSpecificTimeMenu.java |   3 +
 .../gui/tasks/scheduler/EditTimesMenu.java    |   2 -
 .../com/hooks/PAPIPlaceholders.java           | 105 +----
 .../playbosswar/com/language/LanguageKey.java |  13 +-
 .../com/permissions/PermissionUtils.java      |   1 +
 .../BukkitSchedulerAdapter.java               |   2 +-
 .../FoliaSchedulerAdapter.java                |  48 +-
 .../SchedulerAdapter.java                     |   2 +-
 .../playbosswar/com/tasks/AdHocCommand.java   |  66 +++
 .../com/tasks/AdHocCommandRunner.java         |  35 ++
 .../com/tasks/AdHocCommandsManager.java       | 143 ++++++
 .../com/tasks/PopulateScheduleRunner.java     |  31 ++
 .../playbosswar/com/tasks/ScheduledTask.java  |  21 +
 .../java/me/playbosswar/com/tasks/Task.java   |  10 +
 .../me/playbosswar/com/tasks/TaskRunner.java  | 156 ++-----
 .../com/tasks/TaskValidationHelpers.java      |   1 -
 .../playbosswar/com/tasks/TasksManager.java   | 419 ++++++++----------
 .../com/utils/CommandExecutor.java            | 374 ++++++++++++++++
 .../java/me/playbosswar/com/utils/Files.java  |  10 +
 .../me/playbosswar/com/utils/Messages.java    |   2 +
 .../me/playbosswar/com/utils/TaskUtils.java   |  42 --
 .../java/me/playbosswar/com/utils/Tools.java  |  97 ++++
 .../com/utils/gson/GsonConverter.java         |   2 +
 .../com/utils/gson/GsonZonedDateTime.java     |  22 +
 src/main/resources/languages/default.json     |  13 +-
 src/main/resources/languages/en.json          |  13 +-
 src/main/resources/plugin.yml                 |   2 +-
 51 files changed, 1668 insertions(+), 579 deletions(-)
 create mode 100644 docs/docs/configuration/adhoc-commands.md
 create mode 100644 src/main/java/me/playbosswar/com/gui/tasks/ScheduledExecutionsMenu.java
 delete mode 100644 src/main/java/me/playbosswar/com/gui/tasks/general/TextInputConversationPrompt.java
 rename src/main/java/me/playbosswar/com/{scheduler => reflections}/BukkitSchedulerAdapter.java (95%)
 rename src/main/java/me/playbosswar/com/{scheduler => reflections}/FoliaSchedulerAdapter.java (73%)
 rename src/main/java/me/playbosswar/com/{scheduler => reflections}/SchedulerAdapter.java (88%)
 create mode 100644 src/main/java/me/playbosswar/com/tasks/AdHocCommand.java
 create mode 100644 src/main/java/me/playbosswar/com/tasks/AdHocCommandRunner.java
 create mode 100644 src/main/java/me/playbosswar/com/tasks/AdHocCommandsManager.java
 create mode 100644 src/main/java/me/playbosswar/com/tasks/PopulateScheduleRunner.java
 create mode 100644 src/main/java/me/playbosswar/com/tasks/ScheduledTask.java
 create mode 100644 src/main/java/me/playbosswar/com/utils/CommandExecutor.java
 delete mode 100644 src/main/java/me/playbosswar/com/utils/TaskUtils.java
 create mode 100644 src/main/java/me/playbosswar/com/utils/gson/GsonZonedDateTime.java

diff --git a/build.gradle b/build.gradle
index f0526e8d..41365944 100644
--- a/build.gradle
+++ b/build.gradle
@@ -9,7 +9,7 @@ java {
 }
 
 group = 'me.playbosswar.com'
-version = '8.14.1'
+version = '8.15.0'
 description = 'CommandTimer'
 
 repositories {
@@ -74,7 +74,7 @@ publishing {
         maven(MavenPublication) {
             groupId = 'me.playbosswar.com'
             artifactId = 'commandtimer'
-            version = '8.14.1'
+            version = '8.15.0'
 
             from components.java
         }
diff --git a/docs/docs/configuration/adhoc-commands.md b/docs/docs/configuration/adhoc-commands.md
new file mode 100644
index 00000000..6e7b8bb3
--- /dev/null
+++ b/docs/docs/configuration/adhoc-commands.md
@@ -0,0 +1,139 @@
+---
+sidebar_position: 3
+---
+
+# Ad-Hoc Commands
+
+Ad-hoc commands allow you to schedule one-time command executions at a specific time in the future without creating a full [task](../jargon#task). This is perfect for temporary commands, delayed actions, or one-off scheduled executions.
+
+## Overview
+
+Ad-hoc commands are single-use scheduled commands that execute once at a specified time. Unlike regular tasks, they don't have intervals, conditions, or multiple commands - they're designed for simple, one-time executions.
+
+### Key Features
+
+- **One-time execution**: Commands execute once at the scheduled time
+- **Flexible scheduling**: Schedule commands to run at any future time
+- **All gender types supported**: Use any [gender](commands.md#genders) for command execution
+- **Persistent storage**: Commands are saved to disk and survive server restarts
+- **GUI management**: View and manage scheduled ad-hoc commands through the GUI
+
+## Command Syntax
+
+Schedule an ad-hoc command using the `/cmt schedule` command:
+
+```
+/cmt schedule [-after <time>] [-gender <gender>] <command>
+```
+
+### Parameters
+
+- **`-after <time>`** (optional): Delay before execution. Format: `1h10m5s` (hours, minutes, seconds)
+  - Examples: `30s`, `5m`, `1h30m`, `2h15m30s`
+  
+- **`-gender <gender>`** (optional): The [gender](commands.md#genders) to use for execution
+  - Valid options: `CONSOLE`, `PLAYER`, `OPERATOR`, `CONSOLE_PER_USER`, `CONSOLE_PER_USER_OFFLINE`, `CONSOLE_PROXY`
+  - Default: `CONSOLE`
+  
+- **`<command>`** (required): The command to execute (without the leading `/`)
+
+### Examples
+
+#### Basic Examples
+
+```bash
+# Schedule a broadcast message in 5 minutes
+/cmt schedule -after 5m say Server maintenance in 5 minutes!
+
+# Schedule a command to run in 1 hour
+/cmt schedule -after 1h weather clear
+
+# Schedule a command to run in 2 hours, 15 minutes, and 30 seconds
+/cmt schedule -after 2h15m30s time set day
+```
+
+#### Using Different Genders
+
+```bash
+# Execute as console (default)
+/cmt schedule -after 10m say Announcement
+
+# Execute for each online player
+/cmt schedule -after 30m -gender CONSOLE_PER_USER give %player_name% diamond 1
+
+# Execute as if each player is OP
+/cmt schedule -after 1h -gender OPERATOR gamemode creative %player_name%
+
+# Execute for each player (respects permissions)
+/cmt schedule -after 2h -gender PLAYER home
+```
+
+#### Real-World Use Cases
+
+```bash
+# Schedule a server restart announcement
+/cmt schedule -after 30m say Server restarting in 30 minutes!
+/cmt schedule -after 15m say Server restarting in 15 minutes!
+/cmt schedule -after 5m say Server restarting in 5 minutes!
+/cmt schedule -after 1m say Server restarting in 1 minute!
+
+# Schedule a timed event start
+/cmt schedule -after 1h -gender CONSOLE_PER_USER title %player_name% title {"text":"Event Starting!"}
+
+# Schedule maintenance commands
+/cmt schedule -after 2h save-all
+/cmt schedule -after 2h5m say Maintenance complete!
+
+# Schedule player rewards
+/cmt schedule -after 24h -gender CONSOLE_PER_USER give %player_name% emerald 10
+```
+
+## Managing Ad-Hoc Commands
+
+### GUI Management
+
+You can view and manage ad-hoc commands through the **Scheduled Executions** menu:
+
+1. Open the main menu: `/cmt`
+2. Click on **Scheduled Executions**
+3. Use the filter button to show only ad-hoc commands (filter: "Ad-Hoc Only")
+4. Right-click on an ad-hoc command to cancel it
+
+## Differences from Regular Tasks
+
+| Feature | Ad-Hoc Commands | Regular Tasks |
+|----------|----------------|---------------|
+| **Execution** | One-time only | Recurring or event-based |
+| **Commands** | Single command | Multiple commands |
+| **Intervals** | Not supported | Supported |
+| **Conditions** | Not supported | Supported |
+| **Events** | Not supported | Supported |
+| **Execution Modes** | Not applicable | ALL, ORDERED, RANDOM, INTERVAL |
+| **Use Case** | Temporary, one-off commands | Permanent, recurring automation |
+
+## Permissions
+
+- **`commandtimer.schedule`**: Required to schedule ad-hoc commands
+- **`commandtimer.manage`**: Required to view the GUI and manage commands
+
+## Troubleshooting
+
+### Command Not Executing
+
+- Check that the scheduled time has passed
+- Verify the command syntax is correct
+- Check server logs for execution errors
+- Ensure the ad-hoc command runner is active (should start automatically)
+
+### Command Executing Too Early/Late
+
+- Commands execute within 0.5 seconds of their scheduled time
+- Server lag may cause slight delays
+- For precise timing, schedule commands slightly earlier than needed
+
+### Commands Lost After Restart
+
+- Commands are saved to disk and should persist
+- Check that the scheduled time hasn't passed yet
+- Only non-executed commands are loaded on startup
+
diff --git a/docs/docs/configuration/conditions.md b/docs/docs/configuration/conditions.md
index 351e5014..84c68450 100644
--- a/docs/docs/configuration/conditions.md
+++ b/docs/docs/configuration/conditions.md
@@ -14,11 +14,11 @@ Conditions can have one of the following types:
 - `AND`: Creates a group of conditions. Each of these conditions needs to be true to execute your [task](../jargon#task).
 - `OR`: Creates a group of conditions. One of these conditions needs to be true to execute your [task](../jargon#task). Even if you have 50 conditions that do not match but one does, the [task](../jargon#task) will still go through
 
-When using `AND` and `OR`, more conditions can be nested. Nesting does not have a depth limit, meaning you could have an `AND` condition in an `OR` condition in an `OR` condition in an `AND` condition which itself contains 4 different `SIMPLE` and `NOT` conditions. It is good to draw a visual map yourself before doing these nested conditions, because it can be cumberstone to debug in case there is an issue.
+When using `AND` and `OR`, more conditions can be nested. Nesting does not have a depth limit, meaning you could have an `AND` condition in an `OR` condition in an `OR` condition in an `AND` condition which itself contains 4 different `SIMPLE` and `NOT` conditions. It is good to draw a visual map yourself before doing these nested conditions, because it can be cumbersome to debug in case there is an issue.
 
 ## Available conditions
 
-Conditions are made availabel through [extensions](../extensions). This means that CommandTimer by default will not have any conditions, making the whole conditions engine useless if no [extensions](../extensions) are installed.
+Conditions are made available through [extensions](../extensions). This means that CommandTimer by default will not have any conditions, making the whole conditions engine useless if no [extensions](../extensions) are installed.
 
 ## Condition values
 
diff --git a/docs/docs/configuration/index.md b/docs/docs/configuration/index.md
index 919d0f03..b1f2d29e 100644
--- a/docs/docs/configuration/index.md
+++ b/docs/docs/configuration/index.md
@@ -6,5 +6,6 @@ sidebar_position: 2
 
 - [Commands](commands.md)
 - [Schedules and Intervals](schedules.md)
+- [Ad-Hoc Commands](adhoc-commands.md)
 - [Conditions](conditions.md)
 - [Others](others.md)
diff --git a/docs/docs/developers/index.md b/docs/docs/developers/index.md
index 2247a19b..5c71eb73 100644
--- a/docs/docs/developers/index.md
+++ b/docs/docs/developers/index.md
@@ -23,7 +23,6 @@ dependencies {
 ### Maven
 
 ```xml
-
 <repositories>
     <repository>
         <id>jitpack.io</id>
@@ -33,7 +32,6 @@ dependencies {
 ```
 
 ```xml
-
 <dependency>
     <groupId>com.github.titivermeesch</groupId>
     <artifactId>CommandTimer</artifactId>
@@ -50,5 +48,4 @@ functionalities are not available there, the internal CommandTimer API can be us
 
 ## Contributing
 
-Did you found a bug or want to do a general improvement on the plugin or the documentation itself? Feel free to open a
-PR!
+Did you find a bug or want to make a general improvement to the plugin or the documentation? Feel free to open a PR!
diff --git a/docs/docs/extensions/index.md b/docs/docs/extensions/index.md
index 9d852ce2..c3792f2f 100644
--- a/docs/docs/extensions/index.md
+++ b/docs/docs/extensions/index.md
@@ -19,7 +19,7 @@ Once the jar file is in that folder, you should see the extension in different m
 Here is a list of extensions that can be installed. Official extensions are made by the team behind CommandTimer, while
 community extensions, as the name says, are made by the community.
 
-### Oficial extensions
+### Official extensions
 
 - [Time Extension](https://www.spigotmc.org/resources/time-conditions-commandtimer-extension.105591/)
 - [Player Extension](https://www.spigotmc.org/resources/player-conditions-commandtimer-extension.97186/)
diff --git a/docs/docs/faq.md b/docs/docs/faq.md
index 87358e0e..6b6c528b 100644
--- a/docs/docs/faq.md
+++ b/docs/docs/faq.md
@@ -5,7 +5,7 @@ sidebar_position: 8
 
 ## Can I execute a task on restart only
 
-Yes, by using [execution limits](configuration/others#Execution-limits).
+Yes, by using [execution limits](configuration/others#execution-limits).
 
 1. Set the execution limit to 1
 2. Activate the feature "reset execution after restart"
diff --git a/docs/docs/intro.md b/docs/docs/intro.md
index d752f7b3..135078e7 100644
--- a/docs/docs/intro.md
+++ b/docs/docs/intro.md
@@ -25,23 +25,25 @@ Clicking the paper will create a fresh task for you.
 | `/cmt activate <task>`   | Enable the specified task                                                                         | `commandtimer.activate` or `commandtimer.toggle`    |
 | `/cmt deactivate <task>` | Disable the specified task                                                                        | `commandtimer.deactivate`  or `commandtimer.toggle` |
 | `/cmt execute <task>`    | Instantly execute the specified task                                                              | `commandtimer.execute`                              |
+| `/cmt schedule`          | Schedule a one-time [ad-hoc command](configuration/adhoc-commands)                                | `commandtimer.schedule`                             |
 | `/cmt reload`            | Reload the plugin. Extensions will not be reloaded. **It is not recommended to use this command** | `commandtimer.manage`                               |
 
 ## Configuration file
 
 The global configuration file allows you to change the global behaviour of CommandTimer:
 
-- `timeonload`: Show the current server time in the console when the plugin loads
-- `debug`: Enable debug mode. This will print additional information to the console
-- `showUpdateMessage`: Show a message in the chat when a plugin update is available
-- `timezoneOverwrite`: Overwrite the timezone of the server (**This feature does not work right now**)
-- `timezoneOverwriteValue`: The timezone to overwrite the server timezone with (**This feature does not work right now**)
-- `language`: The language to use for the plugin. You can add more languages under the `languages` folder
-- `disablePapiPlaceholderWarnings`: Disable the warning message that appears when a PAPI placeholder is not used correctly
+| Option                          | Description                                                                                 |
+|---------------------------------|---------------------------------------------------------------------------------------------|
+| `timeonload`                    | Show the current server time in the console when the plugin loads                           |
+| `debug`                         | Enable debug mode. This will print additional information to the console                    |
+| `showUpdateMessage`             | Show a message in the chat when a plugin update is available                                |
+| `timezoneOverwrite`             | Overwrite the timezone of the server (**Not working currently**)                            |
+| `timezoneOverwriteValue`        | The timezone to overwrite the server timezone with (**Not working currently**)              |
+| `language`                      | The language to use for the plugin. You can add more languages under the `languages` folder |
+| `disablePapiPlaceholderWarnings`| Disable the warning message that appears when a PAPI placeholder is not used correctly      |
 
+## Other Languages
 
-# Other languages
-
-Here is a list of community maintained translations. These are not guaranteed to always be up to date
+Here is a list of community maintained translations. These are not guaranteed to always be up to date.
 
 - Chinese: https://snowcutieowo.github.io/CommandTimer/#/
diff --git a/docs/docs/jargon.md b/docs/docs/jargon.md
index c1a95cc1..1f4e9645 100644
--- a/docs/docs/jargon.md
+++ b/docs/docs/jargon.md
@@ -1,12 +1,25 @@
 ---
-sidebar_position: 8
+sidebar_position: 10
 ---
+
 # Jargon
 
-The jargon is a collection of names and definitions specificly targetting a certain group or topic, in this case CommandTimer.
+The jargon is a collection of names and definitions specifically targeting a certain group or topic, in this case CommandTimer.
 
-You don't necessarily need to read this; other documentation pages will directly reference to this page.
+You don't necessarily need to read this; other documentation pages will directly reference this page.
 
 ## Task
 
-A task is a group of commands linked to a group of rules and conditions. Usually a task groups together commands that are all related to each-other, or execute different things to achieve a common goal.
\ No newline at end of file
+A task is a group of commands linked to a group of rules and conditions. Usually a task groups together commands that are all related to each other, or execute different things to achieve a common goal.
+
+## Gender
+
+A gender defines how and for whom a command is executed. See [Genders](configuration/commands#genders) for all available options.
+
+## Interval
+
+An interval is a duration that defines how often a task should be executed. See [Intervals](configuration/schedules#intervals) for more details.
+
+## Condition
+
+A condition is a rule that must be met before a task can execute. Conditions are provided by [extensions](extensions).
\ No newline at end of file
diff --git a/docs/docs/jsonschema.md b/docs/docs/jsonschema.md
index f813aa26..87926902 100644
--- a/docs/docs/jsonschema.md
+++ b/docs/docs/jsonschema.md
@@ -104,7 +104,31 @@ Documentation about the Events Engine can be found [here](events)
 |-------------|------------------------------------------------------|-------------------------------------------------------------------------------------|
 | `fieldName` | Name of the parameter                                | `string`                                                                            |
 | `value`     | Given value for the configured parameter             | `any`                                                                               |
-| `compare`   | Compare value between event value and passed `value` | `EQUAL`, `GREATER_THAN`, `LESS_THAN`, `GREATER_OR_EQUAL_THAN`, `LESS_OR_EQUAL_THEN` |
+| `compare`   | Compare value between event value and passed `value` | `EQUAL`, `GREATER_THAN`, `LESS_THAN`, `GREATER_OR_EQUAL_THAN`, `LESS_OR_EQUAL_THAN` |
+
+## Ad-Hoc Command
+
+Ad-hoc commands are stored in `plugins/CommandTimer/ad-hoc-commands/` as individual JSON files. See [Ad-Hoc Commands](configuration/adhoc-commands) for more information.
+
+| Field           | Description                                                      | Type                                     |
+|-----------------|------------------------------------------------------------------|------------------------------------------|
+| `id`            | Unique identifier for the ad-hoc command. **Do not update manually** | `UUID`                                   |
+| `command`       | Command to execute. Do not include `/` in front of the command   | `string`                                 |
+| `gender`        | Gender of the command                                            | [Gender](configuration/commands#genders) |
+| `scheduledTime` | The date and time when the command should be executed            | `ISO-8601 DateTime`                      |
+| `executed`      | Whether the command has been executed. **Do not update manually** | `boolean`                                |
+
+### Ad-Hoc Command example
+
+```json
+{
+  "id": "550e8400-e29b-41d4-a716-446655440000",
+  "command": "say Server maintenance in 5 minutes!",
+  "gender": "CONSOLE",
+  "scheduledTime": "2025-12-07T15:30:00+01:00",
+  "executed": false
+}
+```
 
 ## Example
 
diff --git a/docs/docs/miscellaneous.md b/docs/docs/miscellaneous.md
index 9074e00f..1a2be838 100644
--- a/docs/docs/miscellaneous.md
+++ b/docs/docs/miscellaneous.md
@@ -1,3 +1,7 @@
+---
+sidebar_position: 9
+---
+
 # Miscellaneous
 
 ## Metrics
diff --git a/docs/docs/placeholders.md b/docs/docs/placeholders.md
index b4a95e7d..aa9a1329 100644
--- a/docs/docs/placeholders.md
+++ b/docs/docs/placeholders.md
@@ -28,7 +28,7 @@ to take into account all active tasks
 ## Fallback values
 
 `nextExecution`, `nextExecutionFormat`, `timeFormat` and `nextTaskName` can be suffixed with a fallback value in
-case there is no next execution anymore. For example- `%commandtimer_task_nextExecutionFormat_No next execution%`
+case there is no next execution anymore. For example: `%commandtimer_task_nextExecutionFormat_No next execution%`
 
 ## PAPI Placeholders
 
diff --git a/docs/docs/storage/index.md b/docs/docs/storage/index.md
index b3cf1ad4..6c2516bf 100644
--- a/docs/docs/storage/index.md
+++ b/docs/docs/storage/index.md
@@ -5,7 +5,7 @@ sidebar_position: 3
 
 # Storage
 
-There are currently 2 options to tasks. Local JSON files is the default option.
+There are currently 2 options to store tasks. Local JSON files is the default option.
 
 ## Local JSON files
 
@@ -16,6 +16,8 @@ with that task. The ID is visible in the global tasks list (`/cmt` command).
 
 ## SQL Database (BETA)
 
+**Before trying to set this up, be aware that this feature is not be production ready. Certain features could be missing or feel buggy. Please request support on Discord if you are experiencing issues**
+
 CommandTimer supports SQL databases since v8.9.0. To use this feature you need to set up the following section in
 `config.yml`:
 
diff --git a/java17-build.gradle b/java17-build.gradle
index af128f43..6d5cb24d 100644
--- a/java17-build.gradle
+++ b/java17-build.gradle
@@ -10,7 +10,7 @@ java {
 
 
 group = 'me.playbosswar.com'
-version = '8.14.1'
+version = '8.15.0'
 description = 'CommandTimer'
 
 repositories {
@@ -63,7 +63,7 @@ publishing {
         maven(MavenPublication) {
             groupId = 'me.playbosswar.com'
             artifactId = 'commandtimer-java17'
-            version = '8.14.1'
+            version = '8.15.0'
 
             from components.java
         }
diff --git a/java21-build.gradle b/java21-build.gradle
index 345b52f6..e116da2d 100644
--- a/java21-build.gradle
+++ b/java21-build.gradle
@@ -10,7 +10,7 @@ java {
 
 
 group = 'me.playbosswar.com'
-version = '8.14.1'
+version = '8.15.0'
 description = 'CommandTimer'
 
 repositories {
@@ -67,7 +67,7 @@ publishing {
         maven(MavenPublication) {
             groupId = 'me.playbosswar.com'
             artifactId = 'commandtimer-java21'
-            version = '8.14.1'
+            version = '8.15.0'
             from components.java
         }
     }
diff --git a/src/main/java/me/playbosswar/com/CommandTimerPlugin.java b/src/main/java/me/playbosswar/com/CommandTimerPlugin.java
index 315da0d9..5f086181 100644
--- a/src/main/java/me/playbosswar/com/CommandTimerPlugin.java
+++ b/src/main/java/me/playbosswar/com/CommandTimerPlugin.java
@@ -16,9 +16,10 @@
 import me.playbosswar.com.hooks.HooksManager;
 import me.playbosswar.com.hooks.Metrics;
 import me.playbosswar.com.language.LanguageManager;
-import me.playbosswar.com.scheduler.BukkitSchedulerAdapter;
-import me.playbosswar.com.scheduler.FoliaSchedulerAdapter;
-import me.playbosswar.com.scheduler.SchedulerAdapter;
+import me.playbosswar.com.reflections.BukkitSchedulerAdapter;
+import me.playbosswar.com.reflections.FoliaSchedulerAdapter;
+import me.playbosswar.com.reflections.SchedulerAdapter;
+import me.playbosswar.com.tasks.AdHocCommandsManager;
 import me.playbosswar.com.tasks.Task;
 import me.playbosswar.com.tasks.TasksManager;
 import me.playbosswar.com.tasks.persistors.*;
@@ -45,6 +46,7 @@ public class CommandTimerPlugin extends JavaPlugin implements Listener {
     private static HooksManager hooksManager;
     private static InventoryManager inventoryManager;
     private static TasksManager tasksManager;
+    private static AdHocCommandsManager adHocCommandsManager;
     private static ConditionEngineManager conditionEngineManager;
     private static EventsManager eventsManager;
     public static Metrics metrics;
@@ -105,6 +107,7 @@ public void onEnable() {
         metrics = new Metrics(CommandTimerPlugin.getPlugin(), 9657);
         hooksManager = new HooksManager();
         tasksManager = new TasksManager(this);
+        adHocCommandsManager = new AdHocCommandsManager(this);
         inventoryManager = new InventoryManager(this);
         conditionEngineManager = new ConditionEngineManager();
         eventsManager = new EventsManager(tasksManager);
@@ -122,6 +125,9 @@ public void onEnable() {
     @Override
     public void onDisable() {
         tasksManager.disable();
+        if(adHocCommandsManager != null) {
+            adHocCommandsManager.disable();
+        }
         conditionEngineManager.onDisable();
         saveDefaultConfig();
         plugin = null;
@@ -192,6 +198,14 @@ public void setTasksManager(TasksManager tasksManager) {
         CommandTimerPlugin.tasksManager = tasksManager;
     }
 
+    public AdHocCommandsManager getAdHocCommandsManager() {
+        return adHocCommandsManager;
+    }
+
+    public void setAdHocCommandsManager(AdHocCommandsManager adHocCommandsManager) {
+        CommandTimerPlugin.adHocCommandsManager = adHocCommandsManager;
+    }
+
     public ConditionEngineManager getConditionEngineManager() {
         return conditionEngineManager;
     }
diff --git a/src/main/java/me/playbosswar/com/commands/MainCommand.java b/src/main/java/me/playbosswar/com/commands/MainCommand.java
index 519652ea..38a3c50c 100644
--- a/src/main/java/me/playbosswar/com/commands/MainCommand.java
+++ b/src/main/java/me/playbosswar/com/commands/MainCommand.java
@@ -6,8 +6,11 @@
 import me.playbosswar.com.language.LanguageKey;
 import me.playbosswar.com.language.LanguageManager;
 import me.playbosswar.com.permissions.PermissionUtils;
+import me.playbosswar.com.enums.Gender;
+import me.playbosswar.com.tasks.AdHocCommandsManager;
 import me.playbosswar.com.tasks.CommandIntervalExecutorRunnable;
 import me.playbosswar.com.tasks.Task;
+import me.playbosswar.com.tasks.TaskInterval;
 import me.playbosswar.com.tasks.TasksManager;
 import me.playbosswar.com.utils.Files;
 import me.playbosswar.com.utils.Messages;
@@ -22,6 +25,8 @@
 import java.io.IOException;
 import java.nio.file.Paths;
 import java.sql.SQLException;
+import java.time.ZonedDateTime;
+import java.util.ArrayList;
 import java.util.List;
 
 public class MainCommand implements CommandExecutor {
@@ -40,6 +45,67 @@ public boolean onCommand(@NotNull CommandSender sender, @NotNull Command cmd, @N
         }
 
         TasksManager tasksManager = CommandTimerPlugin.getInstance().getTasksManager();
+        AdHocCommandsManager adHocCommandsManager = CommandTimerPlugin.getInstance().getAdHocCommandsManager();
+
+        if(args.length >= 2 && args[0].equalsIgnoreCase("schedule")) {
+            if(!sender.hasPermission("commandtimer.schedule")) {
+                Messages.sendNoPermission(sender);
+                return true;
+            }
+
+            TaskInterval delay = new TaskInterval(0, 0, 0, 0);
+            Gender gender = Gender.CONSOLE;
+            List<String> commandParts = new ArrayList<>();
+
+            for(int i = 1; i < args.length; i++) {
+                String arg = args[i];
+                if(arg.equals("-after")) {
+                    if(i + 1 < args.length) {
+                        String timeStr = args[i + 1];
+                        delay = Tools.parseTimeString(timeStr);
+                        i++;
+                    } else {
+                        Messages.sendMessage(sender, "&cMissing value for -after parameter.");
+                        Messages.sendMessage(sender, "&7Usage: /cmt schedule [-after 1h10m5s] [-gender CONSOLE] <command>");
+                        return true;
+                    }
+                } else if(arg.equals("-gender")) {
+                    if(i + 1 < args.length) {
+                        String genderStr = args[i + 1].toUpperCase();
+                        try {
+                            gender = Gender.valueOf(genderStr);
+                            i++;
+                        } catch(IllegalArgumentException e) {
+                            Messages.sendMessage(sender, "&cInvalid gender: " + genderStr + ". Valid options: CONSOLE, PLAYER, OPERATOR, CONSOLE_PER_USER, CONSOLE_PER_USER_OFFLINE, CONSOLE_PROXY");
+                            return true;
+                        }
+                    } else {
+                        Messages.sendMessage(sender, "&cMissing value for -gender parameter.");
+                        Messages.sendMessage(sender, "&7Usage: /cmt schedule [-after 1h10m5s] [-gender CONSOLE] <command>");
+                        return true;
+                    }
+                } else {
+                    commandParts.add(arg);
+                }
+            }
+
+            if(commandParts.isEmpty()) {
+                Messages.sendMessage(sender, "&cYou must provide a command to schedule.");
+                Messages.sendMessage(sender, "&7Usage: /cmt schedule [-after 1h10m5s] [-gender CONSOLE] <command>");
+                return true;
+            }
+
+            String command = String.join(" ", commandParts);
+            if(command.startsWith("/")) {
+                command = command.substring(1);
+            }
+
+            ZonedDateTime scheduledTime = ZonedDateTime.now().plusSeconds(delay.toSeconds());
+            adHocCommandsManager.scheduleCommand(command, gender, scheduledTime);
+
+            Messages.sendMessage(sender, "&aCommand scheduled successfully");
+            return true;
+        }
 
         if(args.length == 0 && sender instanceof Player) {
             if(!sender.hasPermission("commandtimer.manage")) {
diff --git a/src/main/java/me/playbosswar/com/gui/MainMenu.java b/src/main/java/me/playbosswar/com/gui/MainMenu.java
index 565bb9cd..fe7267fc 100644
--- a/src/main/java/me/playbosswar/com/gui/MainMenu.java
+++ b/src/main/java/me/playbosswar/com/gui/MainMenu.java
@@ -8,6 +8,7 @@
 import me.playbosswar.com.CommandTimerPlugin;
 import me.playbosswar.com.gui.integrations.MainIntegrationsMenu;
 import me.playbosswar.com.gui.tasks.AllTasksMenu;
+import me.playbosswar.com.gui.tasks.ScheduledExecutionsMenu;
 import me.playbosswar.com.language.LanguageKey;
 import me.playbosswar.com.language.LanguageManager;
 import me.playbosswar.com.utils.Items;
@@ -46,6 +47,13 @@ public void init(Player player, InventoryContents contents) {
                 e -> new MainIntegrationsMenu().INVENTORY.open(player));
         contents.set(1, 2, clickableIntegrationsItem);
 
+        ItemStack scheduledExecutionsItem = Items.generateItem(LanguageKey.SCHEDULED_EXECUTIONS_ITEM,
+                XMaterial.CLOCK,
+                languageManager.getList(LanguageKey.SCHEDULED_EXECUTIONS_LORE).toArray(new String[]{}));
+        ClickableItem scheduledExecutionsClickableItem = ClickableItem.of(scheduledExecutionsItem,
+                e -> new ScheduledExecutionsMenu().INVENTORY.open(player));
+        contents.set(1, 3, scheduledExecutionsClickableItem);
+
         SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
         String currentTime = sdf.format(new java.util.Date());
         ItemStack infoItem = Items.generateItem(LanguageKey.GENERAL_INFORMATION_ITEM,
diff --git a/src/main/java/me/playbosswar/com/gui/tasks/EditTaskMenu.java b/src/main/java/me/playbosswar/com/gui/tasks/EditTaskMenu.java
index f7592376..23a83d27 100644
--- a/src/main/java/me/playbosswar/com/gui/tasks/EditTaskMenu.java
+++ b/src/main/java/me/playbosswar/com/gui/tasks/EditTaskMenu.java
@@ -24,9 +24,15 @@ public class EditTaskMenu implements InventoryProvider {
     public SmartInventory INVENTORY;
     private final LanguageManager languageManager = CommandTimerPlugin.getLanguageManager();
     private final Task task;
+    private final Callback<?> onClose;
 
     public EditTaskMenu(Task task) {
+        this(task, null);
+    }
+
+    public EditTaskMenu(Task task, Callback<?> onClose) {
         this.task = task;
+        this.onClose = onClose;
         INVENTORY = SmartInventory.builder()
                 .id("edit-task")
                 .provider(this)
@@ -45,7 +51,6 @@ public void init(Player player, InventoryContents contents) {
             player.closeInventory();
             TextInputManager.getInstance().startTextInput(player, LanguageKey.NEW_TASK_INPUT, text -> {
                 task.setName(text);
-                task.storeInstance();
                 new EditTaskMenu(task).INVENTORY.open(player);
             });
         });
@@ -106,7 +111,13 @@ public void init(Player player, InventoryContents contents) {
             this.INVENTORY.open(player);
         }));
 
-        contents.set(2, 8, ClickableItem.of(Items.getBackItem(), e -> new AllTasksMenu().INVENTORY.open(player)));
+        contents.set(2, 8, ClickableItem.of(Items.getBackItem(), e -> {
+            if (onClose != null) {
+                onClose.execute(null);
+            } else {
+                new AllTasksMenu().INVENTORY.open(player);
+            }
+        }));
     }
 
     public void update(Player player, InventoryContents contents) {
diff --git a/src/main/java/me/playbosswar/com/gui/tasks/ScheduledExecutionsMenu.java b/src/main/java/me/playbosswar/com/gui/tasks/ScheduledExecutionsMenu.java
new file mode 100644
index 00000000..8e7a588c
--- /dev/null
+++ b/src/main/java/me/playbosswar/com/gui/tasks/ScheduledExecutionsMenu.java
@@ -0,0 +1,199 @@
+package me.playbosswar.com.gui.tasks;
+
+import com.cryptomorin.xseries.XMaterial;
+import fr.minuskube.inv.ClickableItem;
+import fr.minuskube.inv.SmartInventory;
+import fr.minuskube.inv.content.InventoryContents;
+import fr.minuskube.inv.content.InventoryProvider;
+import fr.minuskube.inv.content.Pagination;
+import me.playbosswar.com.CommandTimerPlugin;
+import me.playbosswar.com.gui.HorizontalIteratorWithBorder;
+import me.playbosswar.com.gui.MainMenu;
+import me.playbosswar.com.language.LanguageKey;
+import me.playbosswar.com.language.LanguageManager;
+import me.playbosswar.com.tasks.AdHocCommand;
+import me.playbosswar.com.tasks.ScheduledTask;
+import me.playbosswar.com.utils.Callback;
+import me.playbosswar.com.utils.Items;
+import me.playbosswar.com.utils.Messages;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.inventory.ItemStack;
+
+import java.io.IOException;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class ScheduledExecutionsMenu implements InventoryProvider {
+    public SmartInventory INVENTORY;
+    private final LanguageManager languageManager = CommandTimerPlugin.getLanguageManager();
+    private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+    private FilterType filterType = FilterType.ALL;
+    
+    private enum FilterType {
+        ALL,
+        TASKS_ONLY,
+        ADHOC_ONLY
+    }
+
+    public ScheduledExecutionsMenu() {
+        INVENTORY = SmartInventory.builder()
+                .id("scheduled-executions")
+                .provider(this)
+                .manager(CommandTimerPlugin.getInstance().getInventoryManager())
+                .size(6, 9)
+                .title(languageManager.get(LanguageKey.SCHEDULED_EXECUTIONS_GUI_TITLE))
+                .build();
+    }
+
+    @Override
+    public void init(Player player, InventoryContents contents) {
+        contents.fillBorders(ClickableItem.empty(XMaterial.BLUE_STAINED_GLASS_PANE.parseItem()));
+        Pagination pagination = contents.pagination();
+
+        pagination.setItems(getAllScheduledExecutionItems(player));
+        new HorizontalIteratorWithBorder(player, contents, INVENTORY);
+
+        ItemStack refreshItem = Items.generateItem(LanguageKey.REFRESH_BUTTON_TITLE, XMaterial.REPEATER,
+                languageManager.getList(LanguageKey.REFRESH_BUTTON_LORE).toArray(new String[]{}));
+        contents.set(0, 8, ClickableItem.of(refreshItem, e -> {
+            player.closeInventory();
+            ScheduledExecutionsMenu newMenu = new ScheduledExecutionsMenu();
+            newMenu.filterType = this.filterType;
+            newMenu.INVENTORY.open(player);
+        }));
+
+        String allLabel = languageManager.get(LanguageKey.FILTER_ALL);
+        String tasksLabel = languageManager.get(LanguageKey.FILTER_TASKS_ONLY);
+        String adhocLabel = languageManager.get(LanguageKey.FILTER_ADHOC_ONLY);
+        
+        String[] filterLore = new String[]{
+            filterType == FilterType.ALL ? "§f» " + allLabel + " §f«" : "§8  " + allLabel,
+            filterType == FilterType.TASKS_ONLY ? "§f» " + tasksLabel + " §f«" : "§8  " + tasksLabel,
+            filterType == FilterType.ADHOC_ONLY ? "§f» " + adhocLabel + " §f«" : "§8  " + adhocLabel,
+            "",
+            "§7Click to cycle"
+        };
+        
+        ItemStack filterItem = Items.generateItem(
+                LanguageKey.FILTER_BUTTON_TITLE, 
+                XMaterial.HOPPER, 
+                filterLore);
+        contents.set(0, 0, ClickableItem.of(filterItem, e -> {
+            filterType = filterType == FilterType.ALL ? FilterType.TASKS_ONLY : 
+                        filterType == FilterType.TASKS_ONLY ? FilterType.ADHOC_ONLY : 
+                        FilterType.ALL;
+            pagination.setItems(getAllScheduledExecutionItems(player));
+            INVENTORY.open(player, 0);
+        }));
+
+        contents.set(5, 8, ClickableItem.of(Items.getBackItem(), e -> new MainMenu().INVENTORY.open(player)));
+    }
+
+    @Override
+    public void update(Player player, InventoryContents contents) {
+
+    }
+
+    private ClickableItem[] getAllScheduledExecutionItems(Player p) {
+        final FilterType currentFilter = this.filterType;
+        List<ScheduledTask> scheduledTasks = new ArrayList<>();
+        if (currentFilter == FilterType.ALL || currentFilter == FilterType.TASKS_ONLY) {
+            scheduledTasks = CommandTimerPlugin.getInstance()
+                    .getTasksManager()
+                    .getScheduledTasks()
+                    .stream()
+                    .filter(scheduledTask -> scheduledTask.getDate().toInstant().toEpochMilli() >= System.currentTimeMillis())
+                    .collect(Collectors.toList());
+        }
+
+        List<AdHocCommand> adHocCommands = new ArrayList<>();
+        if (currentFilter == FilterType.ALL || currentFilter == FilterType.ADHOC_ONLY) {
+            adHocCommands = CommandTimerPlugin.getInstance()
+                    .getAdHocCommandsManager()
+                    .getPendingCommands()
+                    .stream()
+                    .filter(cmd -> cmd.getScheduledTime().toInstant().toEpochMilli() >= System.currentTimeMillis())
+                    .collect(Collectors.toList());
+        }
+
+        List<ExecutionItem> allItems = new ArrayList<>();
+        
+        for (ScheduledTask scheduledTask : scheduledTasks) {
+            allItems.add(new ExecutionItem(scheduledTask.getDate(), scheduledTask, null));
+        }
+        
+        for (AdHocCommand adHocCommand : adHocCommands) {
+            allItems.add(new ExecutionItem(adHocCommand.getScheduledTime(), null, adHocCommand));
+        }
+        
+        allItems.sort(Comparator.comparing(item -> item.date));
+
+        ClickableItem[] items = new ClickableItem[allItems.size()];
+
+        for(int i = 0; i < items.length; i++) {
+            ExecutionItem executionItem = allItems.get(i);
+            ZonedDateTime date = executionItem.date;
+            String formattedDate = date.format(DATE_FORMATTER);
+            
+            if (executionItem.scheduledTask != null) {
+                String[] lore = new String[]{
+                        "§7Task: §e" + executionItem.scheduledTask.getTask().getName(),
+                        "§7Scheduled: §e" + formattedDate,
+                        "",
+                        languageManager.get(LanguageKey.LEFT_CLICK_EDIT)
+                };
+
+                ItemStack item = Items.generateItem("§b" + executionItem.scheduledTask.getTask().getName(), XMaterial.CLOCK, lore);
+                items[i] = ClickableItem.of(item, e -> {
+                    Callback<?> callback = data -> INVENTORY.open(p);
+                    new EditTaskMenu(executionItem.scheduledTask.getTask(), callback).INVENTORY.open(p);
+                });
+            } else if (executionItem.adHocCommand != null) {
+                String[] lore = new String[]{
+                        "§7Command: §e" + executionItem.adHocCommand.getCommand(),
+                        "§7Gender: §e" + executionItem.adHocCommand.getGender().name(),
+                        "§7Scheduled: §e" + formattedDate,
+                        "",
+                        languageManager.get(LanguageKey.RIGHT_CLICK_DELETE)
+                };
+
+                ItemStack item = Items.generateItem("§bAd-Hoc Command", XMaterial.COMMAND_BLOCK, lore);
+                final AdHocCommand adHocCmd = executionItem.adHocCommand;
+                items[i] = ClickableItem.of(item, e -> {
+                    if (e.getClick().equals(ClickType.RIGHT)) {
+                        try {
+                            CommandTimerPlugin.getInstance().getAdHocCommandsManager().removeCommand(adHocCmd);
+                            p.closeInventory();
+                            ScheduledExecutionsMenu newMenu = new ScheduledExecutionsMenu();
+                            newMenu.filterType = currentFilter;
+                            newMenu.INVENTORY.open(p);
+                        } catch (IOException ioException) {
+                            Messages.sendFailedIO(p);
+                            ioException.printStackTrace();
+                        }
+                    }
+                });
+            }
+        }
+
+        return items;
+    }
+    
+    private static class ExecutionItem {
+        final ZonedDateTime date;
+        final ScheduledTask scheduledTask;
+        final AdHocCommand adHocCommand;
+        
+        ExecutionItem(ZonedDateTime date, ScheduledTask scheduledTask, AdHocCommand adHocCommand) {
+            this.date = date;
+            this.scheduledTask = scheduledTask;
+            this.adHocCommand = adHocCommand;
+        }
+    }
+}
+
diff --git a/src/main/java/me/playbosswar/com/gui/tasks/general/GeneralLimitsMenu.java b/src/main/java/me/playbosswar/com/gui/tasks/general/GeneralLimitsMenu.java
index 782a9709..e2c0924a 100644
--- a/src/main/java/me/playbosswar/com/gui/tasks/general/GeneralLimitsMenu.java
+++ b/src/main/java/me/playbosswar/com/gui/tasks/general/GeneralLimitsMenu.java
@@ -56,6 +56,7 @@ public void init(Player player, InventoryContents contents) {
             if(e.isRightClick()) {
                 task.setTimesExecuted(0);
                 task.storeInstance();
+                CommandTimerPlugin.getInstance().getTasksManager().resetScheduleForTask(task);
                 this.INVENTORY.open(player);
             }
         });
diff --git a/src/main/java/me/playbosswar/com/gui/tasks/general/TextInputConversationPrompt.java b/src/main/java/me/playbosswar/com/gui/tasks/general/TextInputConversationPrompt.java
deleted file mode 100644
index 0001986f..00000000
--- a/src/main/java/me/playbosswar/com/gui/tasks/general/TextInputConversationPrompt.java
+++ /dev/null
@@ -1,46 +0,0 @@
-package me.playbosswar.com.gui.tasks.general;
-
-import me.playbosswar.com.CommandTimerPlugin;
-import me.playbosswar.com.language.LanguageKey;
-import me.playbosswar.com.language.LanguageManager;
-import me.playbosswar.com.utils.Callback;
-import org.bukkit.conversations.ConversationContext;
-import org.bukkit.conversations.Prompt;
-import org.bukkit.conversations.StringPrompt;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-public class TextInputConversationPrompt extends StringPrompt {
-    private final String title;
-    LanguageManager languageManager = CommandTimerPlugin.getLanguageManager();
-    private final Callback<String> callback;
-
-    public TextInputConversationPrompt(String title, Callback<String> callback) {
-        super();
-        this.title = title;
-        this.callback = callback;
-    }
-
-    public TextInputConversationPrompt(LanguageKey languageKey, Callback<String> callback) {
-        super();
-        this.title = languageManager.get(languageKey);
-        this.callback = callback;
-    }
-
-    public TextInputConversationPrompt(Callback<String> callback) {
-        super();
-        this.title = languageManager.get(LanguageKey.TEXT_INPUT_DEFAULT);
-        this.callback = callback;
-    }
-
-    @Override
-    public @NotNull String getPromptText(@NotNull ConversationContext context) {
-        return this.title;
-    }
-
-    @Override
-    public @Nullable Prompt acceptInput(@NotNull ConversationContext context, @Nullable String input) {
-        callback.execute(input);
-        return Prompt.END_OF_CONVERSATION;
-    }
-}
diff --git a/src/main/java/me/playbosswar/com/gui/tasks/scheduler/EditHourMenu.java b/src/main/java/me/playbosswar/com/gui/tasks/scheduler/EditHourMenu.java
index 0c88834e..416e0271 100644
--- a/src/main/java/me/playbosswar/com/gui/tasks/scheduler/EditHourMenu.java
+++ b/src/main/java/me/playbosswar/com/gui/tasks/scheduler/EditHourMenu.java
@@ -52,6 +52,7 @@ public void init(Player player, InventoryContents contents) {
                 usedTime = taskTime.getTime1();
             }
             task.storeInstance();
+            CommandTimerPlugin.getInstance().getTasksManager().resetScheduleForTask(task);
         }
 
         LocalTime finalUsedTime = usedTime;
@@ -144,5 +145,6 @@ private void setTime(Task task, LocalTime time) {
         }
 
         task.storeInstance();
+        CommandTimerPlugin.getInstance().getTasksManager().resetScheduleForTask(task);
     }
 }
diff --git a/src/main/java/me/playbosswar/com/gui/tasks/scheduler/EditIntervalMenu.java b/src/main/java/me/playbosswar/com/gui/tasks/scheduler/EditIntervalMenu.java
index 2fd2b0af..fc8fa6c3 100644
--- a/src/main/java/me/playbosswar/com/gui/tasks/scheduler/EditIntervalMenu.java
+++ b/src/main/java/me/playbosswar/com/gui/tasks/scheduler/EditIntervalMenu.java
@@ -46,6 +46,7 @@ public void init(Player player, InventoryContents contents) {
         contents.set(1, 1, ClickableItem.of(Items.getAddItem(), e -> {
             interval.incrementDays();
             task.storeInstance();
+            CommandTimerPlugin.getInstance().getTasksManager().resetScheduleForTask(task);
             refresh(player);
         }));
         ClickableTextInputButton daysClocks = new ClickableTextInputButton(
@@ -57,6 +58,7 @@ public void init(Player player, InventoryContents contents) {
                     int days = Integer.parseInt(data);
                     interval.setDays(days);
                     task.storeInstance();
+                    CommandTimerPlugin.getInstance().getTasksManager().resetScheduleForTask(task);
                     refresh(player);
                 }
         );
@@ -64,6 +66,7 @@ public void init(Player player, InventoryContents contents) {
         contents.set(3, 1, ClickableItem.of(Items.getSubstractItem(), e -> {
             interval.decrementDays();
             task.storeInstance();
+            CommandTimerPlugin.getInstance().getTasksManager().resetScheduleForTask(task);
             refresh(player);
         }));
 
@@ -71,6 +74,7 @@ public void init(Player player, InventoryContents contents) {
         contents.set(1, 3, ClickableItem.of(Items.getAddItem(), e -> {
             interval.incrementHours();
             task.storeInstance();
+            CommandTimerPlugin.getInstance().getTasksManager().resetScheduleForTask(task);
             refresh(player);
         }));
         ClickableTextInputButton hoursClock = new ClickableTextInputButton(
@@ -82,6 +86,7 @@ public void init(Player player, InventoryContents contents) {
                     int hours = Integer.parseInt(data);
                     interval.setHours(hours);
                     task.storeInstance();
+                    CommandTimerPlugin.getInstance().getTasksManager().resetScheduleForTask(task);
                     refresh(player);
                 }
         );
@@ -89,6 +94,7 @@ public void init(Player player, InventoryContents contents) {
         contents.set(3, 3, ClickableItem.of(Items.getSubstractItem(), e -> {
             interval.decrementHours();
             task.storeInstance();
+            CommandTimerPlugin.getInstance().getTasksManager().resetScheduleForTask(task);
             refresh(player);
         }));
 
@@ -96,6 +102,7 @@ public void init(Player player, InventoryContents contents) {
         contents.set(1, 5, ClickableItem.of(Items.getAddItem(), e -> {
             interval.incrementMinutes();
             task.storeInstance();
+            CommandTimerPlugin.getInstance().getTasksManager().resetScheduleForTask(task);
             refresh(player);
         }));
         ClickableTextInputButton minutesClock = new ClickableTextInputButton(
@@ -108,6 +115,7 @@ public void init(Player player, InventoryContents contents) {
                     int minutes = Integer.parseInt(data);
                     interval.setMinutes(minutes);
                     task.storeInstance();
+                    CommandTimerPlugin.getInstance().getTasksManager().resetScheduleForTask(task);
                     refresh(player);
                 }
         );
@@ -115,6 +123,7 @@ public void init(Player player, InventoryContents contents) {
         contents.set(3, 5, ClickableItem.of(Items.getSubstractItem(), e -> {
             interval.decrementMinutes();
             task.storeInstance();
+            CommandTimerPlugin.getInstance().getTasksManager().resetScheduleForTask(task);
             refresh(player);
         }));
 
@@ -122,6 +131,7 @@ public void init(Player player, InventoryContents contents) {
         contents.set(1, 7, ClickableItem.of(Items.getAddItem(), e -> {
             interval.incrementSeconds();
             task.storeInstance();
+            CommandTimerPlugin.getInstance().getTasksManager().resetScheduleForTask(task);
             refresh(player);
         }));
         ClickableTextInputButton secondsClock = new ClickableTextInputButton(
@@ -141,6 +151,7 @@ public void init(Player player, InventoryContents contents) {
         contents.set(3, 7, ClickableItem.of(Items.getSubstractItem(), e -> {
             interval.decrementSeconds();
             task.storeInstance();
+            CommandTimerPlugin.getInstance().getTasksManager().resetScheduleForTask(task);
             refresh(player);
         }));
 
diff --git a/src/main/java/me/playbosswar/com/gui/tasks/scheduler/EditSpecificTimeMenu.java b/src/main/java/me/playbosswar/com/gui/tasks/scheduler/EditSpecificTimeMenu.java
index 2beed523..166879c1 100644
--- a/src/main/java/me/playbosswar/com/gui/tasks/scheduler/EditSpecificTimeMenu.java
+++ b/src/main/java/me/playbosswar/com/gui/tasks/scheduler/EditSpecificTimeMenu.java
@@ -69,6 +69,7 @@ public void init(Player player, InventoryContents contents) {
             if(e.isRightClick()) {
                 taskTime.setTime2(null);
                 task.storeInstance();
+                CommandTimerPlugin.getInstance().getTasksManager().resetScheduleForTask(task);
                 this.INVENTORY.open(player);
             }
         });
@@ -80,6 +81,7 @@ public void init(Player player, InventoryContents contents) {
         contents.set(1, 3, ClickableItem.of(minecraftTimeItem, e -> {
             taskTime.toggleMinecraftTime();
             task.storeInstance();
+            CommandTimerPlugin.getInstance().getTasksManager().resetScheduleForTask(task);
             this.INVENTORY.open(player);
         }));
 
@@ -91,6 +93,7 @@ public void init(Player player, InventoryContents contents) {
             Callback<List<String>> worldCallback = worlds -> {
                 taskTime.setWorld(worlds.get(0));
                 task.storeInstance();
+                CommandTimerPlugin.getInstance().getTasksManager().resetScheduleForTask(task);
                 new EditSpecificTimeMenu(task, taskTime).INVENTORY.open(player);
             };
 
diff --git a/src/main/java/me/playbosswar/com/gui/tasks/scheduler/EditTimesMenu.java b/src/main/java/me/playbosswar/com/gui/tasks/scheduler/EditTimesMenu.java
index 501b8ddd..7a06a97f 100644
--- a/src/main/java/me/playbosswar/com/gui/tasks/scheduler/EditTimesMenu.java
+++ b/src/main/java/me/playbosswar/com/gui/tasks/scheduler/EditTimesMenu.java
@@ -49,7 +49,6 @@ public void init(Player player, InventoryContents contents) {
         ClickableItem clickableAddItem = ClickableItem.of(addItem, e -> {
             TaskTime taskTime = new TaskTime(LocalTime.parse("14:00:00"), false);
             task.addTime(taskTime);
-            task.storeInstance();
             new EditSpecificTimeMenu(task, taskTime).INVENTORY.open(player);
         });
         contents.set(0, 0, clickableAddItem);
@@ -89,7 +88,6 @@ private ClickableItem[] getAllTimes(Player p) {
 
                 if(e.getClick().equals(ClickType.RIGHT)) {
                     task.removeTime(taskTime);
-                    task.storeInstance();
                     this.INVENTORY.open(p);
                 }
             });
diff --git a/src/main/java/me/playbosswar/com/hooks/PAPIPlaceholders.java b/src/main/java/me/playbosswar/com/hooks/PAPIPlaceholders.java
index ebf7e6de..0c9078bb 100644
--- a/src/main/java/me/playbosswar/com/hooks/PAPIPlaceholders.java
+++ b/src/main/java/me/playbosswar/com/hooks/PAPIPlaceholders.java
@@ -3,6 +3,7 @@
 import me.clip.placeholderapi.expansion.PlaceholderExpansion;
 import me.playbosswar.com.CommandTimerPlugin;
 import me.playbosswar.com.utils.Tools;
+import me.playbosswar.com.tasks.ScheduledTask;
 import me.playbosswar.com.tasks.Task;
 import me.playbosswar.com.tasks.TaskTime;
 import me.playbosswar.com.utils.Messages;
@@ -62,7 +63,12 @@ public String onPlaceholderRequest(Player player, @NotNull String identifier) {
         String fallbackMessage = placeholder.getFallbackMessage();
 
         if(placeholder.getTaskName().equals("ALLTASKS")) {
-            task = getSoonestTask(CommandTimerPlugin.getInstance().getTasksManager().getActiveTasks());
+            ScheduledTask scheduledTask = CommandTimerPlugin.getInstance().getTasksManager().getNextScheduledTaskForTask(task);
+            if(scheduledTask == null) {
+                return fallbackMessage;
+            }
+
+            task = scheduledTask.getTask();
         }
 
         if(task == null) {
@@ -122,75 +128,13 @@ private String getSecondsText(Task task, String fallbackMessage, boolean format)
 
     // Get time in seconds before next task execution
     private long getNextExecution(Task task) {
-        long now = new Date().getTime();
-        // TODO: Take into account the days
-        if (!task.getTimes().isEmpty()) {
-            List<TaskTime> rangeTimes = task.getTimes().stream().filter(t -> t.getTime2() != null)
-                    .collect(Collectors.toList());
-
-            // If there are no range times, use the single times with the standard
-            // calculation
-            Date date = TaskTimeUtils.getSoonestTaskTime(task, task.getTimes());
-            if (rangeTimes.isEmpty()) {
-                if (date == null || !task.isActive()) {
-                    return -1;
-                }
-
-                return (date.getTime() - now) / 1000;
-            } else {
-                Calendar cal = Calendar.getInstance();
-                cal.setTimeInMillis(now);
-                int currentSeconds = cal.get(Calendar.HOUR_OF_DAY) * 3600 +
-                        cal.get(Calendar.MINUTE) * 60 +
-                        cal.get(Calendar.SECOND);
-
-                List<TaskTime> applicableTimes = new ArrayList<>();
-                for (TaskTime rangeTime : rangeTimes) {
-                    int startSeconds = rangeTime.getTime1().getHour() * 3600 +
-                            rangeTime.getTime1().getMinute() * 60 +
-                            rangeTime.getTime1().getSecond();
-                    int endSeconds = rangeTime.getTime2().getHour() * 3600 +
-                            rangeTime.getTime2().getMinute() * 60 +
-                            rangeTime.getTime2().getSecond();
-
-                    // Handle range spanning to next day
-                    if (endSeconds < startSeconds) {
-                        if (currentSeconds >= startSeconds || currentSeconds <= endSeconds) {
-                            applicableTimes.add(rangeTime);
-                        }
-                    } else if (currentSeconds >= startSeconds && currentSeconds <= endSeconds) {
-                        applicableTimes.add(rangeTime);
-                    }
-                }
-
-                if (applicableTimes.isEmpty()) {
-                    if (date == null || !task.isActive()) {
-                        return -1;
-                    }
-
-                    return (date.getTime() - now) / 1000;
-                }
-
-                Interval interval = new Interval(task.getLastExecuted().getTime(), now);
-                Duration period = interval.toDuration();
-                long timeLeft = task.getInterval().toSeconds() - period.getStandardSeconds();
-                if ((timeLeft < 0 || !task.isActive())) {
-                    return -1;
-                }
-
-                return timeLeft;
-            }
-        }
-
-        Interval interval = new Interval(task.getLastExecuted().getTime(), now);
-        Duration period = interval.toDuration();
-        long timeLeft = task.getInterval().toSeconds() - period.getStandardSeconds();
-
-        if ((timeLeft < 0 || !task.isActive())) {
+        ScheduledTask taskScheduled = CommandTimerPlugin.getInstance().getTasksManager().getNextScheduledTaskForTask(task);
+        if(taskScheduled == null) {
             return -1;
         }
 
-        return timeLeft;
+        long now = System.currentTimeMillis();
+        return (taskScheduled.getDate().toInstant().toEpochMilli() - now) / 1000;
     }
 
     private long getLastExecution(Task task) {
@@ -212,6 +156,9 @@ private String getNextExecutionText(Task task, String fallbackMessage, boolean f
         }
 
         if(format) {
+            if(timeFormat == null) {
+                timeFormat = seconds > 86400 ? "DD:HH:mm:ss" : "HH:mm:ss";
+            }
             return Tools.getTimeString((int) seconds, timeFormat);
         }
 
@@ -226,6 +173,9 @@ private String getLastExecutionText(Task task, String fallbackMessage, boolean f
         }
 
         if(format) {
+            if(timeFormat == null) {
+                timeFormat = seconds > 86400 ? "DD:HH:mm:ss" : "HH:mm:ss";
+            }
             return Tools.getTimeString((int) seconds, timeFormat);
         }
 
@@ -233,27 +183,10 @@ private String getLastExecutionText(Task task, String fallbackMessage, boolean f
     }
 
     private String getNextExecutionText(Task task, String fallbackMessage, boolean format) {
-        return getNextExecutionText(task, fallbackMessage, format, "HH:mm:ss");
+        return getNextExecutionText(task, fallbackMessage, format, null);
     }
 
     private String getLastExecutionText(Task task, String fallbackMessage, boolean format) {
-        return getLastExecutionText(task, fallbackMessage, format, "HH:mm:ss");
-    }
-
-    // Get first task that will execute
-    private Task getSoonestTask(List<Task> tasks) {
-        Map<Task, Long> timeTillExecution = new HashMap<>();
-        tasks.forEach(t -> {
-            long seconds = getNextExecution(t);
-            if(seconds > 0) {
-                timeTillExecution.put(t, seconds);
-            }
-        });
-
-        if(timeTillExecution.isEmpty()) {
-            return null;
-        }
-
-        return Collections.min(timeTillExecution.entrySet(), Map.Entry.comparingByValue()).getKey();
+        return getLastExecutionText(task, fallbackMessage, format, null);
     }
 }
\ No newline at end of file
diff --git a/src/main/java/me/playbosswar/com/language/LanguageKey.java b/src/main/java/me/playbosswar/com/language/LanguageKey.java
index fc0ea01c..bb8d8b70 100644
--- a/src/main/java/me/playbosswar/com/language/LanguageKey.java
+++ b/src/main/java/me/playbosswar/com/language/LanguageKey.java
@@ -154,7 +154,18 @@ public enum LanguageKey {
     METRICS_INTEGRATION_DESCRIPTION,
     USED_MINECRAFT_WORLD,
     PLUGIN_RELOADED,
-    MINECRAFT_TIME;
+    MINECRAFT_TIME,
+    SCHEDULED_EXECUTIONS_GUI_TITLE,
+    SCHEDULED_EXECUTIONS_ITEM,
+    SCHEDULED_EXECUTIONS_LORE,
+    REFRESH_BUTTON_TITLE,
+    REFRESH_BUTTON_LORE,
+    FILTER_BUTTON_TITLE,
+    FILTER_BUTTON_LORE,
+    FILTER_BUTTON_CURRENT,
+    FILTER_ALL,
+    FILTER_TASKS_ONLY,
+    FILTER_ADHOC_ONLY;
 
     public static LanguageKey getByTag(String tag) {
         return Arrays.stream(values()).filter(value -> value.toString().equals(tag.toUpperCase())).findFirst()
diff --git a/src/main/java/me/playbosswar/com/permissions/PermissionUtils.java b/src/main/java/me/playbosswar/com/permissions/PermissionUtils.java
index b5200c79..3985597c 100644
--- a/src/main/java/me/playbosswar/com/permissions/PermissionUtils.java
+++ b/src/main/java/me/playbosswar/com/permissions/PermissionUtils.java
@@ -9,6 +9,7 @@ public static boolean playerHasSomeAccess(CommandSender sender) {
                 || sender.hasPermission("commandtimer.activate")
                 || sender.hasPermission("commandtimer.deactivate")
                 || sender.hasPermission("commandtimer.update")
+                || sender.hasPermission("commandtimer.schedule")
                 || sender.hasPermission("commandtimer.toggle");
     }
 }
diff --git a/src/main/java/me/playbosswar/com/scheduler/BukkitSchedulerAdapter.java b/src/main/java/me/playbosswar/com/reflections/BukkitSchedulerAdapter.java
similarity index 95%
rename from src/main/java/me/playbosswar/com/scheduler/BukkitSchedulerAdapter.java
rename to src/main/java/me/playbosswar/com/reflections/BukkitSchedulerAdapter.java
index 60620d33..1a531d2f 100644
--- a/src/main/java/me/playbosswar/com/scheduler/BukkitSchedulerAdapter.java
+++ b/src/main/java/me/playbosswar/com/reflections/BukkitSchedulerAdapter.java
@@ -1,4 +1,4 @@
-package me.playbosswar.com.scheduler;
+package me.playbosswar.com.reflections;
 
 import org.bukkit.Bukkit;
 import org.bukkit.plugin.Plugin;
diff --git a/src/main/java/me/playbosswar/com/scheduler/FoliaSchedulerAdapter.java b/src/main/java/me/playbosswar/com/reflections/FoliaSchedulerAdapter.java
similarity index 73%
rename from src/main/java/me/playbosswar/com/scheduler/FoliaSchedulerAdapter.java
rename to src/main/java/me/playbosswar/com/reflections/FoliaSchedulerAdapter.java
index ca3e8f97..b5a68c7f 100644
--- a/src/main/java/me/playbosswar/com/scheduler/FoliaSchedulerAdapter.java
+++ b/src/main/java/me/playbosswar/com/reflections/FoliaSchedulerAdapter.java
@@ -1,11 +1,10 @@
-package me.playbosswar.com.scheduler;
+package me.playbosswar.com.reflections;
 
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
 import java.lang.invoke.MethodType;
 import java.lang.invoke.MethodHandles.Lookup;
 import java.util.Objects;
-import java.util.concurrent.TimeUnit;
 import java.util.function.Consumer;
 import java.util.logging.Level;
 import java.util.logging.Logger;
@@ -20,9 +19,10 @@ public class FoliaSchedulerAdapter implements SchedulerAdapter {
     private static final boolean SUPPORTED;
     private static final boolean HAS_IS_CANCELLED;
 
+    private static @Nullable MethodHandle GLOBAL_SCHEDULER_RUN;
+    private static @Nullable MethodHandle GLOBAL_SCHEDULER_RUN_DELAYED;
+    private static @Nullable MethodHandle GLOBAL_SCHEDULER_RUN_RATE;
     private static @Nullable MethodHandle ASYNC_SCHEDULER_RUN;
-    private static @Nullable MethodHandle ASYNC_SCHEDULER_RUN_DELAYED;
-    private static @Nullable MethodHandle ASYNC_SCHEDULER_RUN_RATE;
     private static @Nullable MethodHandle SCHEDULED_TASK_IS_CANCELLED;
     private static @Nullable MethodHandle SCHEDULED_TASK_CANCEL;
 
@@ -37,19 +37,26 @@ public class FoliaSchedulerAdapter implements SchedulerAdapter {
             ));
             SCHEDULED_TASK_IS_CANCELLED = lookup.findVirtual(scheduledTaskType, "isCancelled", MethodType.methodType(boolean.class));
 
-            Class<?> asyncSchedulerType = Class.forName("io.papermc.paper.threadedregions.scheduler.GlobalRegionScheduler");
+            Class<?> globalSchedulerType = Class.forName("io.papermc.paper.threadedregions.scheduler.GlobalRegionScheduler");
+            MethodHandle getGlobalScheduler = lookup.findVirtual(Server.class, "getGlobalRegionScheduler", MethodType.methodType(globalSchedulerType));
+            Object globalScheduler = getGlobalScheduler.invoke(Bukkit.getServer());
 
-            MethodHandle getAsyncScheduler = lookup.findVirtual(Server.class, "getGlobalRegionScheduler", MethodType.methodType(asyncSchedulerType));
-            Object asyncScheduler = getAsyncScheduler.invoke(Bukkit.getServer());
-
-            ASYNC_SCHEDULER_RUN = lookup.findVirtual(asyncSchedulerType, "run", MethodType.methodType(
+            GLOBAL_SCHEDULER_RUN = lookup.findVirtual(globalSchedulerType, "run", MethodType.methodType(
                     scheduledTaskType, Plugin.class, Consumer.class
-            )).bindTo(asyncScheduler);
-            ASYNC_SCHEDULER_RUN_DELAYED = lookup.findVirtual(asyncSchedulerType, "runDelayed", MethodType.methodType(
+            )).bindTo(globalScheduler);
+            GLOBAL_SCHEDULER_RUN_DELAYED = lookup.findVirtual(globalSchedulerType, "runDelayed", MethodType.methodType(
                     scheduledTaskType, Plugin.class, Consumer.class, long.class
-            )).bindTo(asyncScheduler);
-            ASYNC_SCHEDULER_RUN_RATE = lookup.findVirtual(asyncSchedulerType, "runAtFixedRate", MethodType.methodType(
+            )).bindTo(globalScheduler);
+            GLOBAL_SCHEDULER_RUN_RATE = lookup.findVirtual(globalSchedulerType, "runAtFixedRate", MethodType.methodType(
                     scheduledTaskType, Plugin.class, Consumer.class, long.class, long.class
+            )).bindTo(globalScheduler);
+
+            Class<?> asyncSchedulerType = Class.forName("io.papermc.paper.threadedregions.scheduler.AsyncScheduler");
+            MethodHandle getAsyncScheduler = lookup.findVirtual(Server.class, "getAsyncScheduler", MethodType.methodType(asyncSchedulerType));
+            Object asyncScheduler = getAsyncScheduler.invoke(Bukkit.getServer());
+
+            ASYNC_SCHEDULER_RUN = lookup.findVirtual(asyncSchedulerType, "runNow", MethodType.methodType(
+                    scheduledTaskType, Plugin.class, Consumer.class
             )).bindTo(asyncScheduler);
 
             try {
@@ -80,7 +87,7 @@ public static boolean isSupported() {
     public BukkitTask runTaskTimer(Runnable runnable, long delay, long period) {
         try {
             final Consumer<Object> consumer = task -> runnable.run();
-            return new ScheduledTask(Objects.requireNonNull(ASYNC_SCHEDULER_RUN_RATE).invoke(plugin, consumer, delay, period));
+            return new ScheduledTask(Objects.requireNonNull(GLOBAL_SCHEDULER_RUN_RATE).invoke(plugin, consumer, delay, period));
         } catch (Throwable e) {
             plugin.getLogger().log(Level.SEVERE, "Error in task scheduling by the Folia scheduler adapter", e);
         }
@@ -91,19 +98,18 @@ public BukkitTask runTaskTimer(Runnable runnable, long delay, long period) {
     public BukkitTask runTask(Runnable runnable) {
         try {
             final Consumer<Object> consumer = task -> runnable.run();
-            return new ScheduledTask(Objects.requireNonNull(ASYNC_SCHEDULER_RUN).invoke(plugin, consumer));
+            return new ScheduledTask(Objects.requireNonNull(GLOBAL_SCHEDULER_RUN).invoke(plugin, consumer));
         } catch (Throwable e) {
             plugin.getLogger().log(Level.SEVERE, "Error in task scheduling by the Folia scheduler adapter", e);
         }
         return new ScheduledTask(null);
     }
 
-
     @Override
     public BukkitTask runTaskLater(Runnable runnable, long delay) {
         try {
             final Consumer<Object> consumer = task -> runnable.run();
-            return new ScheduledTask(Objects.requireNonNull(ASYNC_SCHEDULER_RUN_DELAYED).invoke(plugin, consumer, delay));
+            return new ScheduledTask(Objects.requireNonNull(GLOBAL_SCHEDULER_RUN_DELAYED).invoke(plugin, consumer, delay));
         } catch (Throwable e) {
             plugin.getLogger().log(Level.SEVERE, "Error in task scheduling by the Folia scheduler adapter", e);
         }
@@ -112,7 +118,13 @@ public BukkitTask runTaskLater(Runnable runnable, long delay) {
 
     @Override
     public BukkitTask runTaskAsynchronously(Runnable runnable) {
-        return runTask(runnable);
+        try {
+            final Consumer<Object> consumer = task -> runnable.run();
+            return new ScheduledTask(Objects.requireNonNull(ASYNC_SCHEDULER_RUN).invoke(plugin, consumer));
+        } catch (Throwable e) {
+            plugin.getLogger().log(Level.SEVERE, "Error in task scheduling by the Folia scheduler adapter", e);
+        }
+        return new ScheduledTask(null);
     }
 
     private class ScheduledTask implements BukkitTask {
diff --git a/src/main/java/me/playbosswar/com/scheduler/SchedulerAdapter.java b/src/main/java/me/playbosswar/com/reflections/SchedulerAdapter.java
similarity index 88%
rename from src/main/java/me/playbosswar/com/scheduler/SchedulerAdapter.java
rename to src/main/java/me/playbosswar/com/reflections/SchedulerAdapter.java
index 4dd87181..1b4f5145 100644
--- a/src/main/java/me/playbosswar/com/scheduler/SchedulerAdapter.java
+++ b/src/main/java/me/playbosswar/com/reflections/SchedulerAdapter.java
@@ -1,4 +1,4 @@
-package me.playbosswar.com.scheduler;
+package me.playbosswar.com.reflections;
 
 import org.bukkit.scheduler.BukkitTask;
 
diff --git a/src/main/java/me/playbosswar/com/tasks/AdHocCommand.java b/src/main/java/me/playbosswar/com/tasks/AdHocCommand.java
new file mode 100644
index 00000000..f0dd0fcf
--- /dev/null
+++ b/src/main/java/me/playbosswar/com/tasks/AdHocCommand.java
@@ -0,0 +1,66 @@
+package me.playbosswar.com.tasks;
+
+import me.playbosswar.com.enums.Gender;
+
+import java.time.ZonedDateTime;
+import java.util.UUID;
+
+public class AdHocCommand {
+    private UUID id;
+    private String command;
+    private Gender gender;
+    private ZonedDateTime scheduledTime;
+    private boolean executed;
+
+    public AdHocCommand(String command, Gender gender, ZonedDateTime scheduledTime) {
+        this.id = UUID.randomUUID();
+        this.command = command;
+        this.gender = gender;
+        this.scheduledTime = scheduledTime;
+        this.executed = false;
+    }
+
+    AdHocCommand() {
+    }
+
+    public UUID getId() {
+        return id;
+    }
+
+    public void setId(UUID id) {
+        this.id = id;
+    }
+
+    public String getCommand() {
+        return command;
+    }
+
+    public void setCommand(String command) {
+        this.command = command;
+    }
+
+    public Gender getGender() {
+        return gender;
+    }
+
+    public void setGender(Gender gender) {
+        this.gender = gender;
+    }
+
+    public ZonedDateTime getScheduledTime() {
+        return scheduledTime;
+    }
+
+    public void setScheduledTime(ZonedDateTime scheduledTime) {
+        this.scheduledTime = scheduledTime;
+    }
+
+    public boolean isExecuted() {
+        return executed;
+    }
+
+    public void setExecuted(boolean executed) {
+        this.executed = executed;
+    }
+}
+
diff --git a/src/main/java/me/playbosswar/com/tasks/AdHocCommandRunner.java b/src/main/java/me/playbosswar/com/tasks/AdHocCommandRunner.java
new file mode 100644
index 00000000..fd5f6e9e
--- /dev/null
+++ b/src/main/java/me/playbosswar/com/tasks/AdHocCommandRunner.java
@@ -0,0 +1,35 @@
+package me.playbosswar.com.tasks;
+
+import me.playbosswar.com.CommandTimerPlugin;
+import me.playbosswar.com.utils.Messages;
+
+import java.util.List;
+import java.util.TimerTask;
+
+public class AdHocCommandRunner implements Runnable {
+    private final AdHocCommandsManager manager;
+
+    public AdHocCommandRunner(AdHocCommandsManager manager) {
+        this.manager = manager;
+    }
+
+    @Override
+    public void run() {
+        CommandTimerPlugin.getScheduler().runTaskTimer(new TimerTask() {
+            @Override
+            public void run() {
+                if (manager.stopRunner) {
+                    Messages.sendDebugConsole("Ignoring ad-hoc command execution because manager has been stopped");
+                    return;
+                }
+
+                List<AdHocCommand> commandsToExecute = manager.getCommandsToExecute();
+                commandsToExecute.forEach(command -> {
+                    Messages.sendDebugConsole("Executing ad-hoc command: " + command.getCommand());
+                    manager.processCommandExecution(command);
+                });
+            }
+        }, 1, 10);
+    }
+}
+
diff --git a/src/main/java/me/playbosswar/com/tasks/AdHocCommandsManager.java b/src/main/java/me/playbosswar/com/tasks/AdHocCommandsManager.java
new file mode 100644
index 00000000..3cb705cb
--- /dev/null
+++ b/src/main/java/me/playbosswar/com/tasks/AdHocCommandsManager.java
@@ -0,0 +1,143 @@
+package me.playbosswar.com.tasks;
+
+import me.playbosswar.com.CommandTimerPlugin;
+import me.playbosswar.com.enums.Gender;
+import me.playbosswar.com.utils.CommandExecutor;
+import me.playbosswar.com.utils.Files;
+import me.playbosswar.com.utils.Messages;
+import me.playbosswar.com.utils.gson.GsonConverter;
+import org.bukkit.plugin.Plugin;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.nio.file.Paths;
+import java.time.ZonedDateTime;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+import org.json.simple.parser.JSONParser;
+import org.json.simple.parser.ParseException;
+
+public class AdHocCommandsManager {
+    private List<AdHocCommand> loadedCommands = new ArrayList<>();
+    private Thread runnerThread;
+    public boolean stopRunner = false;
+
+    public AdHocCommandsManager(Plugin plugin) {
+        loadedCommands.addAll(loadAdHocCommandsFromFiles());
+        startRunner();
+    }
+
+    public AdHocCommand scheduleCommand(String command, Gender gender, ZonedDateTime scheduledTime) {
+        AdHocCommand adHocCommand = new AdHocCommand(command, gender, scheduledTime);
+        loadedCommands.add(adHocCommand);
+        storeCommand(adHocCommand);
+        return adHocCommand;
+    }
+
+    @Nullable
+    public AdHocCommand getCommandById(UUID id) {
+        return loadedCommands.stream()
+                .filter(cmd -> cmd.getId().equals(id))
+                .findFirst()
+                .orElse(null);
+    }
+
+    public void removeCommand(AdHocCommand command) throws IOException {
+        loadedCommands.remove(command);
+        java.nio.file.Files.deleteIfExists(Paths.get(Files.getAdHocCommandFile(command.getId())));
+    }
+
+    public List<AdHocCommand> getLoadedCommands() {
+        return loadedCommands;
+    }
+
+    public List<AdHocCommand> getPendingCommands() {
+        return loadedCommands.stream()
+                .filter(cmd -> !cmd.isExecuted())
+                .collect(Collectors.toList());
+    }
+
+    private void startRunner() {
+        Runnable runner = new AdHocCommandRunner(this);
+        Thread thread = new Thread(runner);
+        thread.start();
+        this.runnerThread = thread;
+    }
+
+    public List<AdHocCommand> getCommandsToExecute() {
+        ZonedDateTime now = ZonedDateTime.now();
+        return loadedCommands.stream()
+                .filter(cmd -> !cmd.isExecuted() && cmd.getScheduledTime().toInstant().toEpochMilli() <= now.toInstant().toEpochMilli())
+                .collect(Collectors.toList());
+    }
+
+    public void processCommandExecution(AdHocCommand adHocCommand) {
+        CommandTimerPlugin.getScheduler().runTaskAsynchronously(() -> {
+            CommandExecutor.ExecutionContext context = new CommandExecutor.ExecutionContext.Builder()
+                    .command(adHocCommand.getCommand())
+                    .gender(adHocCommand.getGender())
+                    .build();
+
+            CommandExecutor.execute(context);
+
+            adHocCommand.setExecuted(true);
+            storeCommand(adHocCommand);
+        });
+    }
+
+    private List<AdHocCommand> loadAdHocCommandsFromFiles() {
+        List<AdHocCommand> commands = new ArrayList<>();
+        File dir = new File(Files.getAdHocCommandsDirectory());
+        if (!dir.exists()) {
+            dir.mkdirs();
+            return commands;
+        }
+
+        File[] directoryListing = dir.listFiles(file -> file.getName().endsWith(".json"));
+        JSONParser jsonParser = new JSONParser();
+        GsonConverter gson = new GsonConverter();
+
+        if (directoryListing != null) {
+            for (File file : directoryListing) {
+                try {
+                    FileReader fr = new FileReader(file.getPath());
+                    AdHocCommand command = gson.fromJson(jsonParser.parse(fr).toString(), AdHocCommand.class);
+                    if (command != null && !command.isExecuted()) {
+                        commands.add(command);
+                    }
+                } catch (IOException | ParseException e) {
+                    Messages.sendConsole("Failed to load ad-hoc command from " + file.getName() + ": " + e.getMessage());
+                }
+            }
+        }
+
+        return commands;
+    }
+
+    private void storeCommand(AdHocCommand command) {
+        GsonConverter gson = new GsonConverter();
+        String json = gson.toJson(command);
+        try {
+            FileWriter jsonFile = new FileWriter(Files.getAdHocCommandFile(command.getId()));
+            jsonFile.write(json);
+            jsonFile.flush();
+            jsonFile.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void disable() {
+        stopRunner = true;
+        if (runnerThread != null && runnerThread.isAlive()) {
+            runnerThread.interrupt();
+        }
+    }
+}
+
diff --git a/src/main/java/me/playbosswar/com/tasks/PopulateScheduleRunner.java b/src/main/java/me/playbosswar/com/tasks/PopulateScheduleRunner.java
new file mode 100644
index 00000000..9eddc8eb
--- /dev/null
+++ b/src/main/java/me/playbosswar/com/tasks/PopulateScheduleRunner.java
@@ -0,0 +1,31 @@
+package me.playbosswar.com.tasks;
+
+import java.util.TimerTask;
+
+import me.playbosswar.com.CommandTimerPlugin;
+import me.playbosswar.com.utils.Messages;
+
+public class PopulateScheduleRunner implements Runnable {
+    private final TasksManager tasksManager;
+
+    public PopulateScheduleRunner(TasksManager tasksManager) {
+        this.tasksManager = tasksManager;
+    }
+
+
+    @Override
+    public void run() {
+        CommandTimerPlugin.getScheduler().runTaskTimer(new TimerTask() {
+            @Override
+            public void run() {
+                if (tasksManager.stopRunner) {
+                    Messages.sendDebugConsole("Ignoring execution because manager has been stopped");
+                    return;
+                }
+
+                tasksManager.getLoadedTasks().forEach(task -> tasksManager.populateScheduleForTask(task));
+            }
+            // Run every 10 seconds
+        }, 1, 20 * 10);
+    }
+}
diff --git a/src/main/java/me/playbosswar/com/tasks/ScheduledTask.java b/src/main/java/me/playbosswar/com/tasks/ScheduledTask.java
new file mode 100644
index 00000000..63e90679
--- /dev/null
+++ b/src/main/java/me/playbosswar/com/tasks/ScheduledTask.java
@@ -0,0 +1,21 @@
+package me.playbosswar.com.tasks;
+
+import java.time.ZonedDateTime;
+
+public class ScheduledTask {
+    private final Task task;
+    private final ZonedDateTime date;
+
+    public ScheduledTask(Task task, ZonedDateTime date) {
+        this.task = task;
+        this.date = date;
+    }
+
+    public Task getTask() {
+        return task;
+    }
+    
+    public ZonedDateTime getDate() {
+        return date;
+    }
+}
diff --git a/src/main/java/me/playbosswar/com/tasks/Task.java b/src/main/java/me/playbosswar/com/tasks/Task.java
index 5a7db7f4..1307ec95 100644
--- a/src/main/java/me/playbosswar/com/tasks/Task.java
+++ b/src/main/java/me/playbosswar/com/tasks/Task.java
@@ -112,6 +112,7 @@ public TaskInterval getInterval() {
     public void setInterval(TaskInterval interval) {
         this.interval = interval;
         storeInstance();
+        CommandTimerPlugin.getInstance().getTasksManager().resetScheduleForTask(this);
     }
 
     public List<TaskTime> getTimes() {
@@ -121,16 +122,19 @@ public List<TaskTime> getTimes() {
     public void setTimes(List<TaskTime> times) {
         this.times = times;
         storeInstance();
+        CommandTimerPlugin.getInstance().getTasksManager().resetScheduleForTask(this);
     }
 
     public void addTime(TaskTime time) {
         this.times.add(time);
         storeInstance();
+        CommandTimerPlugin.getInstance().getTasksManager().resetScheduleForTask(this);
     }
 
     public void removeTime(TaskTime time) {
         times.remove(time);
         storeInstance();
+        CommandTimerPlugin.getInstance().getTasksManager().resetScheduleForTask(this);
     }
 
     public double getRandom() {
@@ -140,6 +144,7 @@ public double getRandom() {
     public void setRandom(double random) {
         this.random = random;
         storeInstance();
+        CommandTimerPlugin.getInstance().getTasksManager().resetScheduleForTask(this);
     }
 
     public List<DayOfWeek> getDays() {
@@ -149,6 +154,7 @@ public List<DayOfWeek> getDays() {
     public void setDays(List<DayOfWeek> days) {
         this.days = days;
         storeInstance();
+        CommandTimerPlugin.getInstance().getTasksManager().resetScheduleForTask(this);
     }
 
     public void toggleDay(DayOfWeek day) {
@@ -159,6 +165,7 @@ public void toggleDay(DayOfWeek day) {
         }
 
         storeInstance();
+        CommandTimerPlugin.getInstance().getTasksManager().resetScheduleForTask(this);
     }
 
     public int getExecutionLimit() {
@@ -168,6 +175,7 @@ public int getExecutionLimit() {
     public void setExecutionLimit(int executionLimit) {
         this.executionLimit = executionLimit;
         storeInstance();
+        CommandTimerPlugin.getInstance().getTasksManager().resetScheduleForTask(this);
     }
 
     public int getTimesExecuted() {
@@ -194,11 +202,13 @@ public void setActive(boolean active) {
         this.active = active;
         this.lastExecuted = new Date();
         storeInstance();
+        CommandTimerPlugin.getInstance().getTasksManager().resetScheduleForTask(this);
     }
 
     public void toggleActive() {
         this.active = !this.active;
         storeInstance();
+        CommandTimerPlugin.getInstance().getTasksManager().resetScheduleForTask(this);
     }
 
     public CommandExecutionMode getCommandExecutionMode() {
diff --git a/src/main/java/me/playbosswar/com/tasks/TaskRunner.java b/src/main/java/me/playbosswar/com/tasks/TaskRunner.java
index 08eae35a..31d43ab3 100644
--- a/src/main/java/me/playbosswar/com/tasks/TaskRunner.java
+++ b/src/main/java/me/playbosswar/com/tasks/TaskRunner.java
@@ -5,16 +5,12 @@
 import me.playbosswar.com.CommandTimerPlugin;
 import me.playbosswar.com.enums.CommandExecutionMode;
 import me.playbosswar.com.utils.Messages;
-import me.playbosswar.com.utils.TaskTimeUtils;
-import me.playbosswar.com.utils.TaskUtils;
 import me.playbosswar.com.utils.Tools;
-import org.bukkit.Bukkit;
-import org.bukkit.World;
 
-import java.time.LocalTime;
-import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.TimerTask;
+import java.util.stream.Collectors;
 
 /**
  * Runnable responsible for scheduling tasks
@@ -27,127 +23,31 @@ public TaskRunner(TasksManager tasksManager) {
     }
 
     private void processTask(Task task) {
-        if(tasksManager.stopRunner) {
+        if (tasksManager.stopRunner) {
             return;
         }
 
         Messages.sendDebugConsole("Checking if " + task.getName() + " can be executed");
 
-        if(!task.isActive()) {
-            Messages.sendDebugConsole("Task is not active");
-            return;
-        }
-
-        if(!TaskUtils.checkTaskDaysContainToday(task)) {
-            Messages.sendDebugConsole("Command can not be executed today");
-            return;
-        }
-
-        if(task.getTimesExecuted() >= task.getExecutionLimit() && task.getExecutionLimit() != -1) {
-            Messages.sendDebugConsole("Task reached the maximum execution limit");
-            return;
-        }
-
-        if(!Tools.randomCheck(task.getRandom())) {
+        if (!Tools.randomCheck(task.getRandom())) {
             Messages.sendDebugConsole("Task has a random execution chance");
             return;
         }
 
-        boolean blockTime = true;
-        if(!task.getTimes().isEmpty()) {
-            Messages.sendDebugConsole("Task is time related, checking if can be executed now");
-
-            for(TaskTime taskTime : task.getTimes()) {
-                if(taskTime.isMinecraftTime()) {
-                    Messages.sendDebugConsole("Task is using minecraft time");
-
-                    World world = Bukkit.getWorld(taskTime.getWorld() == null ? "world" : taskTime.getWorld());
-                    String minecraftTime = Tools.calculateWorldTime(world);
-
-                    Messages.sendDebugConsole("Current minecraft time is " + minecraftTime);
-
-                    LocalTime current = LocalTime.parse(minecraftTime);
-
-                    if(taskTime.isRange()) {
-                        LocalTime startRange = taskTime.getTime1();
-                        LocalTime endRange = taskTime.getTime2();
-
-                        if(current.isBefore(endRange) && current.isAfter(startRange)) {
-                            boolean hasPassedInterval = TaskTimeUtils.hasPassedInterval(task);
-                            if(hasPassedInterval) {
-                                blockTime = false;
-                            }
-                        }
-                    } else {
-                        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm");
-                        if(minecraftTime.equals(taskTime.getTime1().format(formatter))) {
-                            blockTime = false;
-                        }
-                    }
-                } else {
-                    Messages.sendDebugConsole("Found time, checking if execution is needed");
-
-                    LocalTime current = LocalTime.now().withNano(0);
-
-                    if(taskTime.isRange()) {
-                        Messages.sendDebugConsole("Found time range");
-
-                        LocalTime startRange = taskTime.getTime1();
-                        LocalTime endRange = taskTime.getTime2();
-
-                        if(current.isBefore(endRange) && current.isAfter(startRange)) {
-                            Messages.sendDebugConsole("Time is inside time range");
-                            boolean hasPassedInterval = TaskTimeUtils.hasPassedInterval(task);
-                            if(hasPassedInterval) {
-                                Messages.sendDebugConsole("Interval has passed, time range can be executed");
-                                blockTime = false;
-                            }
-                        }
-                    } else {
-                        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss");
-
-                        String currentFormat = current.format(formatter);
-                        String time1Format = taskTime.getTime1().format(formatter);
-
-                        if(!currentFormat.equals(time1Format)) {
-                            Messages.sendDebugConsole("Time " + currentFormat + " does not correspond to " + time1Format);
-                        } else {
-                            blockTime = false;
-                        }
-                    }
-                }
-            }
-        } else {
-            if(task.getInterval().toSeconds() == 0 && !task.getEvents().isEmpty()) {
-                Messages.sendDebugConsole("Timer has no interval set and uses events, skipping");
-                return;
-            }
-            blockTime = false;
-            boolean hasPassedInterval = TaskTimeUtils.hasPassedInterval(task);
-            if(!hasPassedInterval) {
-                Messages.sendDebugConsole("Timer has been executed before");
-                return;
-            }
-        }
-
-        if(blockTime) {
-            Messages.sendDebugConsole("Execution has been blocked because times do not correspond");
-            return;
-        }
-
         CommandExecutionMode executionMode = task.getCommandExecutionMode();
-        if(executionMode.equals(CommandExecutionMode.INTERVAL)) {
-            CommandTimerPlugin.getScheduler().runTaskTimer(
-                    new CommandIntervalExecutorRunnable(task), 1, task.getCommandExecutionInterval().toSeconds() * 20L);
+        if (executionMode.equals(CommandExecutionMode.INTERVAL)) {
+            CommandTimerPlugin.getScheduler().runTaskTimer(new CommandIntervalExecutorRunnable(task), 1,
+                    task.getCommandExecutionInterval().toSeconds() * 20L);
             return;
         }
 
         boolean hasDelayedCommands = task.getCommands().stream().anyMatch(c -> c.getDelay().toSeconds() > 0);
-        if(executionMode.equals(CommandExecutionMode.ORDERED) && hasDelayedCommands) {
-            final int[] accumulatedDelaySeconds = {0};
+        if (executionMode.equals(CommandExecutionMode.ORDERED) && hasDelayedCommands) {
+            final int[] accumulatedDelaySeconds = { 0 };
             task.getCommands().forEach(command -> {
                 CommandTimerPlugin.getScheduler().runTaskLater(
-                        () -> tasksManager.processCommandExecution(task, command), (20L * accumulatedDelaySeconds[0]) + 1);
+                        () -> tasksManager.processCommandExecution(task, command),
+                        (20L * accumulatedDelaySeconds[0]) + 1);
                 accumulatedDelaySeconds[0] += command.getDelay().toSeconds();
             });
             return;
@@ -156,15 +56,14 @@ private void processTask(Task task) {
         // If it remains -1, that means that all commands should be executed
         int selectedCommandIndex = tasksManager.getNextTaskCommandIndex(task);
 
-        if(selectedCommandIndex == -1) {
+        if (selectedCommandIndex == -1) {
             task.setLastExecutedCommandIndex(0);
             CommandTimerPlugin.getScheduler().runTask(
                     () -> task.getCommands().forEach(command -> tasksManager.processCommandExecution(task, command)));
         } else {
             TaskCommand taskCommand = task.getCommands().get(selectedCommandIndex);
             task.setLastExecutedCommandIndex(task.getCommands().indexOf(taskCommand));
-            CommandTimerPlugin.getScheduler().runTask(
-                    () -> tasksManager.processCommandExecution(task, taskCommand));
+            CommandTimerPlugin.getScheduler().runTask(() -> tasksManager.processCommandExecution(task, taskCommand));
         }
 
         task.storeInstance();
@@ -175,20 +74,37 @@ public void run() {
         CommandTimerPlugin.getScheduler().runTaskTimer(new TimerTask() {
             @Override
             public void run() {
-                if(tasksManager.stopRunner) {
+                if (tasksManager.stopRunner) {
                     Messages.sendDebugConsole("Ignoring execution because manager has been stopped");
                     return;
                 }
 
-                List<Task> tasks = CommandTimerPlugin.getInstance().getTasksManager().getLoadedTasks();
+                List<ScheduledTask> tasksToExecute = new ArrayList<>();
+                Boolean exit = false;
+
+                while(!exit) {
+                    // First peek to aggregate a list of tasks to execute
+                    ScheduledTask scheduledTask = tasksManager.getScheduledTasks().peek();
+                    if(scheduledTask == null) {
+                        exit = true;
+                        continue;
+                    }
+
+                    if(scheduledTask.getDate().toInstant().toEpochMilli() > System.currentTimeMillis()) {
+                        exit = true;
+                        continue;
+                    }
+
+                    // Then poll to remove the tasks from the queue
+                    tasksToExecute.add(tasksManager.getScheduledTasks().poll());
+                }
 
-                tasks.forEach(task -> {
+                tasksToExecute.forEach(scheduledTask -> {
                     ITransaction transaction = Sentry.startTransaction("processTask()", "task");
-                    processTask(task);
+                    processTask(scheduledTask.getTask());
                     transaction.finish();
                 });
             }
-            // Sync runner with the clock
-        }, (System.currentTimeMillis() % 20) + 1, 20);
+        }, 1, 10);
     }
 }
\ No newline at end of file
diff --git a/src/main/java/me/playbosswar/com/tasks/TaskValidationHelpers.java b/src/main/java/me/playbosswar/com/tasks/TaskValidationHelpers.java
index 9c650f9d..705eb2f0 100644
--- a/src/main/java/me/playbosswar/com/tasks/TaskValidationHelpers.java
+++ b/src/main/java/me/playbosswar/com/tasks/TaskValidationHelpers.java
@@ -12,7 +12,6 @@
 import me.playbosswar.com.utils.Messages;
 import org.bukkit.OfflinePlayer;
 import org.bukkit.World;
-import org.bukkit.entity.Player;
 import org.jeasy.rules.api.Facts;
 import org.jetbrains.annotations.Nullable;
 
diff --git a/src/main/java/me/playbosswar/com/tasks/TasksManager.java b/src/main/java/me/playbosswar/com/tasks/TasksManager.java
index 9546b46d..bd6f0afb 100644
--- a/src/main/java/me/playbosswar/com/tasks/TasksManager.java
+++ b/src/main/java/me/playbosswar/com/tasks/TasksManager.java
@@ -3,43 +3,40 @@
 import java.io.IOException;
 import java.nio.file.Paths;
 import java.sql.SQLException;
+import java.time.LocalDate;
+import java.time.LocalTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
 import java.util.ArrayList;
-import java.util.Collection;
+import java.util.Comparator;
 import java.util.Date;
 import java.util.List;
-import java.util.Objects;
 import java.util.Optional;
-import java.util.UUID;
-import java.util.stream.Collectors;
-
-import java.io.ByteArrayOutputStream;
-import java.io.DataOutputStream;
+import java.util.PriorityQueue;
+import java.util.Queue;
 import java.util.Random;
+import java.util.stream.Collectors;
 
 import org.bukkit.Bukkit;
-import org.bukkit.OfflinePlayer;
-import org.bukkit.command.CommandException;
-import org.bukkit.entity.Player;
+import org.bukkit.World;
 import org.bukkit.plugin.Plugin;
 import org.jetbrains.annotations.Nullable;
 
 import me.playbosswar.com.CommandTimerPlugin;
 import me.playbosswar.com.enums.CommandExecutionMode;
-import me.playbosswar.com.enums.Gender;
-import me.playbosswar.com.hooks.PAPIHook;
+import me.playbosswar.com.utils.CommandExecutor;
 import me.playbosswar.com.utils.DatabaseUtils;
 import me.playbosswar.com.utils.Files;
 import me.playbosswar.com.utils.Messages;
-import me.playbosswar.com.utils.StringEnhancer;
 import me.playbosswar.com.utils.Tools;
 
-
 public class TasksManager {
-    private static final String CONDITION_NO_MATCH = "Conditions did not match";
     private static final Random RANDOM = new Random();
     private static final String ALPHA_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     private List<Task> loadedTasks = new ArrayList<>();
+    private Queue<ScheduledTask> scheduledTasks = new PriorityQueue<>(Comparator.comparing(ScheduledTask::getDate));
     private Thread runnerThread;
+    private Thread populateScheduleRunnerThread;
     public boolean stopRunner = false;
     public int executionsSinceLastSync = 0;
 
@@ -66,6 +63,7 @@ public TasksManager(Plugin plugin) {
             }
         });
 
+        startPopulateScheduleRunner();
         startRunner();
     }
 
@@ -87,12 +85,13 @@ private static String generateRandomAlphabetic(int length) {
 
     @Nullable
     public Task getTaskByName(String name) {
-        Optional<Task> optionalTask =
-                loadedTasks.stream().filter(task -> task.getName().equalsIgnoreCase(name)).findFirst();
+        Optional<Task> optionalTask = loadedTasks.stream().filter(task -> task.getName().equalsIgnoreCase(name))
+                .findFirst();
         return optionalTask.orElse(null);
     }
 
     public void removeTask(Task task) throws IOException {
+        resetScheduleForTask(task);
         if (CommandTimerPlugin.getPlugin().getConfig().getBoolean("database.enabled")) {
             try {
                 CommandTimerPlugin.getTaskDao().delete(task);
@@ -103,12 +102,13 @@ public void removeTask(Task task) throws IOException {
             }
         } else {
             try {
-                java.nio.file.Files.delete(Paths.get(Files.getTaskFile(task.getId())));
                 loadedTasks.remove(task);
+                java.nio.file.Files.delete(Paths.get(Files.getTaskFile(task.getId())));
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
+
     }
 
     public List<Task> getLoadedTasks() {
@@ -130,251 +130,223 @@ private void startRunner() {
         this.runnerThread = thread;
     }
 
-    private boolean runConsolePerUserCommand(Task task, TaskCommand taskCommand, List<UUID> scopedPlayers) throws CommandException {
-        String command = taskCommand.getCommand();
+    private void startPopulateScheduleRunner() {
+        Runnable runner = new PopulateScheduleRunner(this);
+        Thread thread = new Thread(runner);
+        thread.start();
+        this.populateScheduleRunnerThread = thread;
+    }
 
-        Collection<Player> affectedPlayers = (Collection<Player>) Bukkit.getOnlinePlayers();
-        if (!scopedPlayers.isEmpty()) {
-            affectedPlayers =
-                    scopedPlayers.stream().map(Bukkit::getPlayer).filter(Objects::nonNull).collect(Collectors.toList());
-        }
 
-        boolean delayedExecutions = taskCommand.getInterval().toSeconds() > 0;
-        int i = 0;
-        boolean willExecute = false;
-        for (Player p : affectedPlayers) {
-            if (task.hasCondition()) {
-                boolean valid = TaskValidationHelpers.processCondition(task.getCondition(), p);
-                if (!valid) {
-                    Messages.sendDebugConsole(CONDITION_NO_MATCH);
-                    continue;
-                }
-            }
-            willExecute = true;
-
-            if (delayedExecutions) {
-                CommandTimerPlugin.getScheduler().runTaskLater(() -> {
-                    Bukkit.getServer().dispatchCommand(Bukkit.getConsoleSender(), PAPIHook.parsePAPI(command, p));
-                    executionsSinceLastSync++;
-                }, (20L * i * taskCommand.getInterval().toSeconds()) + 1);
-            } else {
-                CommandTimerPlugin.getScheduler().runTask(() -> Bukkit.getServer().dispatchCommand(Bukkit.getConsoleSender(), PAPIHook.parsePAPI(command, p)));
-                executionsSinceLastSync++;
-            }
-            i++;
+    public void processCommandExecution(Task task, TaskCommand taskCommand) {
+        if (!task.isActive()) {
+            return;
         }
 
-        return willExecute;
-    }
-
-    private boolean runConsolePerUserOfflineCommand(Task task, TaskCommand taskCommand) throws CommandException {
-        String command = taskCommand.getCommand();
-        boolean delayedExecutions = taskCommand.getInterval().toSeconds() > 0;
+        CommandTimerPlugin.getScheduler().runTaskAsynchronously(() -> {
+            CommandExecutor.ExecutionContext.Builder builder = new CommandExecutor.ExecutionContext.Builder()
+                    .command(taskCommand.getCommand())
+                    .gender(taskCommand.getGender())
+                    .interval(taskCommand.getInterval())
+                    .executionCounter(count -> executionsSinceLastSync++);
 
-        int i = 0;
-        // TODO: Caching could be used heres, Bukkit.getOfflinePlayers() is pretty expensive
-        for (OfflinePlayer p : Bukkit.getOfflinePlayers()) {
             if (task.hasCondition()) {
-                boolean valid = TaskValidationHelpers.processCondition(task.getCondition(), p);
-                if (!valid) {
-                    Messages.sendDebugConsole(CONDITION_NO_MATCH);
-                    continue;
-                }
+                builder.conditionChecker(p -> TaskValidationHelpers.processCondition(task.getCondition(), p));
             }
-            if (delayedExecutions) {
-                CommandTimerPlugin.getScheduler().runTaskLater(() -> {
-                    CommandTimerPlugin.getScheduler().runTask(() -> Bukkit.getServer().dispatchCommand(Bukkit.getConsoleSender(), PAPIHook.parsePAPI(command, p)));
-                    executionsSinceLastSync++;
-                }, (20L * i * taskCommand.getInterval().toSeconds()) + 1);
-            } else {
-                CommandTimerPlugin.getScheduler().runTask(() -> Bukkit.getServer().dispatchCommand(Bukkit.getConsoleSender(), PAPIHook.parsePAPI(command, p)));
-                executionsSinceLastSync++;
-            }
-            i++;
-        }
 
-        return true;
-    }
-
-    private boolean runConsolePerUserCommand(Task task, TaskCommand taskCommand) throws CommandException {
-        return runConsolePerUserCommand(task, taskCommand, new ArrayList<>());
-    }
+            boolean executed = CommandExecutor.execute(builder.build());
 
-    private boolean runConsoleCommand(Task task, TaskCommand taskCommand) throws CommandException {
-        if (task.hasCondition()) {
-            boolean valid = TaskValidationHelpers.processCondition(task.getCondition(), null);
-            if (!valid) {
-                Messages.sendDebugConsole(CONDITION_NO_MATCH);
-                return false;
+            if (executed) {
+                task.setLastExecuted(new Date());
+                task.setTimesExecuted(task.getTimesExecuted() + 1);
+                task.storeInstance();
             }
-        }
+        });
+    }
+    
+    public Queue<ScheduledTask> getScheduledTasks() {
+        return scheduledTasks;
+    }
 
-        String command = taskCommand.getCommand();
-        CommandTimerPlugin.getScheduler().runTask(() -> Bukkit.getServer().dispatchCommand(Bukkit.getConsoleSender(), PAPIHook.parsePAPI(command, null)));
-        executionsSinceLastSync++;
-        return true;
+    public void resetScheduleForTask(Task task) {
+        scheduledTasks.removeIf(scheduledTask -> scheduledTask.getTask().getId().equals(task.getId()));
     }
 
-    private boolean runPlayerCommand(Task task, TaskCommand taskCommand, List<UUID> scopedPlayers) {
-        String command = taskCommand.getCommand();
 
-        Collection<Player> affectedPlayers = (Collection<Player>) Bukkit.getOnlinePlayers();
-        if (!scopedPlayers.isEmpty()) {
-            affectedPlayers =
-                    scopedPlayers.stream().map(Bukkit::getPlayer).filter(Objects::nonNull).collect(Collectors.toList());
+    public void populateScheduleForTask(Task task) {
+        Messages.sendDebugConsole("Populating schedule for task: " + task.getName());
+        if (!task.isActive()) {
+            Messages.sendDebugConsole("Task " + task.getName() + " is not active, skipping scheduling");
+            return;
         }
 
-        boolean delayedExecution = taskCommand.getInterval().toSeconds() > 0;
-        int i = 0;
-        boolean willExecute = false;
-        for (Player p : affectedPlayers) {
-            if (task.hasCondition()) {
-                boolean valid = TaskValidationHelpers.processCondition(task.getCondition(), p);
-                if (!valid) {
-                    Messages.sendDebugConsole(CONDITION_NO_MATCH);
-                    continue;
-                }
-            }
+        int executionLimit = task.getExecutionLimit();
+        int timesExecuted = task.getTimesExecuted();
+        long alreadyScheduled = scheduledTasks.stream()
+                .filter(scheduledTask -> scheduledTask.getTask().getId().equals(task.getId())).count();
 
-            willExecute = true;
-            if (delayedExecution) {
-                CommandTimerPlugin.getScheduler().runTaskLater(() -> runForPlayer(p,
-                        command), (20L * i * taskCommand.getInterval().toSeconds()) + 1);
-            } else {
-                runForPlayer(p, command);
-            }
-            i++;
+        if (alreadyScheduled >= 50) {
+            Messages.sendDebugConsole(
+                    "Task " + task.getName() + " has already been scheduled 50 times, skipping scheduling");
+            return;
         }
 
-        return willExecute;
-    }
-
-    private void runForPlayer(Player p, String command) {
-        String parsedCommand = PAPIHook.parsePAPI(command, p);
-        CommandTimerPlugin.getScheduler().runTask(() -> {
-            boolean executed = p.performCommand(parsedCommand);
-
-            if (!executed) {
-                String errorMessage =
-                        new StringEnhancer("Failed to execute command {command}").add("taskName", command).parse();
-                throw new CommandException(errorMessage);
+        int maxToSchedule = 50;
+        if (executionLimit != -1) {
+            int remaining = executionLimit - timesExecuted - (int) alreadyScheduled;
+            if (remaining <= 0) {
+                Messages.sendDebugConsole(
+                        "Task " + task.getName() + " has reached execution limit, skipping scheduling");
+                return;
             }
-            executionsSinceLastSync++;
-        });
-    }
+            maxToSchedule = Math.min(maxToSchedule, remaining);
+        }
 
-    private boolean runPlayerCommand(Task task, TaskCommand taskCommand) {
-        return runPlayerCommand(task, taskCommand, new ArrayList<>());
-    }
+        ZonedDateTime latestScheduledDate = scheduledTasks.stream()
+                .filter(scheduledTask -> scheduledTask.getTask().getId().equals(task.getId()))
+                .map(ScheduledTask::getDate).max(ZonedDateTime::compareTo).orElse(null);
 
-    private boolean runOperatorCommand(Task task, TaskCommand taskCommand, List<UUID> scopedPlayers) {
-        String command = taskCommand.getCommand();
+        if (latestScheduledDate == null) {
+            ZonedDateTime now = ZonedDateTime.now();
+            ZonedDateTime lastExecuted = task.getLastExecuted().toInstant().atZone(ZoneId.systemDefault());
+            latestScheduledDate = lastExecuted.isAfter(now) ? lastExecuted : now;
+        }
 
-        Collection<Player> affectedPlayers = (Collection<Player>) Bukkit.getOnlinePlayers();
-        if (!scopedPlayers.isEmpty()) {
-            affectedPlayers =
-                    scopedPlayers.stream().map(Bukkit::getPlayer).filter(Objects::nonNull).collect(Collectors.toList());
+        if (maxToSchedule <= 0) {
+            return;
         }
 
-        boolean delayedExecutions = taskCommand.getInterval().toSeconds() > 0;
-        int i = 0;
-        boolean willExecute = false;
-        for (Player p : affectedPlayers) {
-            boolean wasAlreadyOp = p.isOp();
+        if (!task.getTimes().isEmpty()) {
+            for (TaskTime taskTime : task.getTimes()) {
+                if (taskTime.isMinecraftTime()) {
+                    World world = Bukkit.getWorld(taskTime.getWorld() == null ? "world" : taskTime.getWorld());
+                    if (world == null) {
+                        continue;
+                    }
 
-            try {
-                p.setOp(true);
-                if (task.hasCondition()) {
-                    boolean valid = TaskValidationHelpers.processCondition(task.getCondition(), p);
-                    if (!valid) {
-                        Messages.sendDebugConsole(CONDITION_NO_MATCH);
-
-                        if (!wasAlreadyOp) {
-                            p.setOp(false);
+                    if (taskTime.isRange()) {
+                        LocalTime startRange = taskTime.getTime1();
+                        LocalTime endRange = taskTime.getTime2();
+
+                        int i = 0;
+                        while (maxToSchedule > 0) {
+                            ZonedDateTime date = Tools.getNextMinecraftTime(world, startRange, i);
+                            if (!task.getDays().contains(date.getDayOfWeek())) {
+                                i++;
+                                continue;
+                            }
+
+                            LocalTime mcTimeAtExecution = Tools.getMinecraftTimeAt(world, date);
+                            if (!(mcTimeAtExecution.isAfter(startRange) && mcTimeAtExecution.isBefore(endRange))) {
+                                i++;
+                                continue;
+                            }
+
+                            if (date.isBefore(latestScheduledDate)) {
+                                i++;
+                                continue;
+                            }
+
+                            scheduledTasks.add(new ScheduledTask(task, date));
+                            maxToSchedule--;
+                            i++;
+                        }
+                    } else {
+                        LocalTime time = taskTime.getTime1();
+
+                        int i = 0;
+                        while (maxToSchedule > 0) {
+                            ZonedDateTime nextMinecraftTime = Tools.getNextMinecraftTime(world, time, i);
+                            if (!task.getDays().contains(nextMinecraftTime.getDayOfWeek())) {
+                                i++;
+                                continue;
+                            }
+
+                            if (nextMinecraftTime.isBefore(latestScheduledDate)) {
+                                i++;
+                                continue;
+                            }
+
+                            scheduledTasks.add(new ScheduledTask(task, nextMinecraftTime));
+                            maxToSchedule--;
+                            i++;
                         }
-                        continue;
                     }
-                }
-                willExecute = true;
+                } else if (taskTime.isRange()) {
+                    LocalTime startRange = taskTime.getTime1();
+                    LocalTime endRange = taskTime.getTime2();
+
+                    int i = 0;
+                    while (maxToSchedule > 0) {
+                        ZonedDateTime date = ZonedDateTime.of(LocalDate.now(), startRange, ZoneId.systemDefault())
+                                .plusSeconds(i * task.getInterval().toSeconds());
+                        if (!task.getDays().contains(date.getDayOfWeek())) {
+                            i++;
+                            continue;
+                        }
 
-                if (delayedExecutions) {
-                    CommandTimerPlugin.getScheduler().runTaskLater(() -> {
-                        p.performCommand(PAPIHook.parsePAPI(command, p));
-                        executionsSinceLastSync++;
-                    }, (20L * i * taskCommand.getInterval().toSeconds()) + 1);
-                } else {
-                    CommandTimerPlugin.getScheduler().runTask(() -> p.performCommand(PAPIHook.parsePAPI(command, p)));
-                    executionsSinceLastSync++;
-                }
+                        if (!(date.toLocalTime().isAfter(startRange) && date.toLocalTime().isBefore(endRange))) {
+                            i++;
+                            continue;
+                        }
 
-            } finally {
-                if (!wasAlreadyOp) {
-                    p.setOp(false);
-                }
-            }
-            i++;
-        }
+                        if (date.isBefore(latestScheduledDate)) {
+                            i++;
+                            continue;
+                        }
 
-        return willExecute;
-    }
+                        scheduledTasks.add(new ScheduledTask(task, date));
+                        maxToSchedule--;
+                        i++;
+                    }
+                } else {
+                    LocalTime time = taskTime.getTime1();
+
+                    int i = 0;
+                    while (maxToSchedule > 0) {
+                        ZonedDateTime date = ZonedDateTime.of(LocalDate.now(), time, ZoneId.systemDefault())
+                                .plusDays(i);
+                        if (!task.getDays().contains(date.getDayOfWeek())) {
+                            i++;
+                            continue;
+                        }
 
-    private boolean runOperatorCommand(Task task, TaskCommand taskCommand) {
-        return runOperatorCommand(task, taskCommand, new ArrayList<>());
-    }
+                        if (date.isBefore(latestScheduledDate)) {
+                            i++;
+                            continue;
+                        }
 
-    private boolean runConsoleProxyCommand(Task task, TaskCommand taskCommand) {
-        if (task.hasCondition()) {
-            boolean valid = TaskValidationHelpers.processCondition(task.getCondition(), null);
-            if (!valid) {
-                Messages.sendDebugConsole(CONDITION_NO_MATCH);
-                return false;
+                        scheduledTasks.add(new ScheduledTask(task, date));
+                        maxToSchedule--;
+                        i++;
+                    }
+                }
             }
+            return;
         }
 
-        String command = taskCommand.getCommand();
-        ByteArrayOutputStream b = new ByteArrayOutputStream();
-        DataOutputStream out = new DataOutputStream(b);
-        try {
-            out.writeUTF("executeConsoleCommand");
-            out.writeUTF(command);
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-
-        Bukkit.getServer().sendPluginMessage(CommandTimerPlugin.getPlugin(), "commandtimer:main", b.toByteArray());
-        executionsSinceLastSync++;
-        return true;
-    }
-
-    public void processCommandExecution(Task task, TaskCommand taskCommand) {
-        if (!task.isActive()) {
+        if (task.getInterval().toSeconds() == 0 && !task.getEvents().isEmpty()) {
+            Messages.sendDebugConsole(
+                    "Task " + task.getName() + "has no interval set and uses events, skipping scheduling");
             return;
         }
 
-        CommandTimerPlugin.getScheduler().runTaskAsynchronously(() -> {
-            Gender gender = taskCommand.getGender();
-
-            boolean executed = false;
-            if (gender.equals(Gender.CONSOLE)) {
-                executed = runConsoleCommand(task, taskCommand);
-            } else if (gender.equals(Gender.PLAYER)) {
-                executed = runPlayerCommand(task, taskCommand);
-            } else if (gender.equals(Gender.OPERATOR)) {
-                executed = runOperatorCommand(task, taskCommand);
-            } else if (gender.equals(Gender.CONSOLE_PER_USER)) {
-                executed = runConsolePerUserCommand(task, taskCommand);
-            } else if (gender.equals(Gender.CONSOLE_PER_USER_OFFLINE)) {
-                executed = runConsolePerUserOfflineCommand(task, taskCommand);
-            } else if (gender.equals(Gender.CONSOLE_PROXY)) {
-                executed = runConsoleProxyCommand(task, taskCommand);
+        int i = 0;
+        while (maxToSchedule > 0) {
+            ZonedDateTime date = latestScheduledDate.plusSeconds(i * task.getInterval().toSeconds());
+            if (!task.getDays().contains(date.getDayOfWeek())) {
+                i++;
+                continue;
             }
 
-            if (executed) {
-                task.setLastExecuted(new Date());
-                task.setTimesExecuted(task.getTimesExecuted() + 1);
-                task.storeInstance();
-            }
-        });
+            scheduledTasks.add(new ScheduledTask(task, date));
+            maxToSchedule--;
+            i++;
+        }
+    }
+
+    public ScheduledTask getNextScheduledTaskForTask(Task task) {
+        return scheduledTasks.stream().filter(scheduledTask -> scheduledTask.getTask().getId().equals(task.getId())).min(Comparator.comparing(ScheduledTask::getDate)).orElse(null);
     }
 
     public int getNextTaskCommandIndex(Task task) {
@@ -402,5 +374,8 @@ public void disable() {
         if (runnerThread != null && runnerThread.isAlive()) {
             runnerThread.interrupt();
         }
+        if (populateScheduleRunnerThread != null && populateScheduleRunnerThread.isAlive()) {
+            populateScheduleRunnerThread.interrupt();
+        }
     }
 }
diff --git a/src/main/java/me/playbosswar/com/utils/CommandExecutor.java b/src/main/java/me/playbosswar/com/utils/CommandExecutor.java
new file mode 100644
index 00000000..11dd54b3
--- /dev/null
+++ b/src/main/java/me/playbosswar/com/utils/CommandExecutor.java
@@ -0,0 +1,374 @@
+package me.playbosswar.com.utils;
+
+import me.playbosswar.com.CommandTimerPlugin;
+import me.playbosswar.com.enums.Gender;
+import me.playbosswar.com.hooks.PAPIHook;
+import me.playbosswar.com.tasks.TaskInterval;
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.CommandException;
+import org.bukkit.entity.Player;
+
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public class CommandExecutor {
+    private static final String CONDITION_NO_MATCH = "Conditions did not match";
+
+    public static class ExecutionContext {
+        private final String command;
+        private final Gender gender;
+        private final TaskInterval interval;
+        private final List<UUID> scopedPlayers;
+        private final Function<OfflinePlayer, Boolean> conditionChecker;
+        private final Runnable onExecution;
+        private final Consumer<Integer> executionCounter;
+
+        private ExecutionContext(Builder builder) {
+            this.command = builder.command;
+            this.gender = builder.gender;
+            this.interval = builder.interval != null ? builder.interval : new TaskInterval(0, 0, 0, 0);
+            this.scopedPlayers = builder.scopedPlayers;
+            this.conditionChecker = builder.conditionChecker;
+            this.onExecution = builder.onExecution;
+            this.executionCounter = builder.executionCounter;
+        }
+
+        public static class Builder {
+            private String command;
+            private Gender gender;
+            private TaskInterval interval;
+            private List<UUID> scopedPlayers;
+            private Function<OfflinePlayer, Boolean> conditionChecker;
+            private Runnable onExecution;
+            private Consumer<Integer> executionCounter;
+
+            public Builder command(String command) {
+                this.command = command;
+                return this;
+            }
+
+            public Builder gender(Gender gender) {
+                this.gender = gender;
+                return this;
+            }
+
+            public Builder interval(TaskInterval interval) {
+                this.interval = interval;
+                return this;
+            }
+
+            public Builder scopedPlayers(List<UUID> scopedPlayers) {
+                this.scopedPlayers = scopedPlayers;
+                return this;
+            }
+
+            public Builder conditionChecker(Function<OfflinePlayer, Boolean> conditionChecker) {
+                this.conditionChecker = conditionChecker;
+                return this;
+            }
+
+            public Builder onExecution(Runnable onExecution) {
+                this.onExecution = onExecution;
+                return this;
+            }
+
+            public Builder executionCounter(Consumer<Integer> executionCounter) {
+                this.executionCounter = executionCounter;
+                return this;
+            }
+
+            public ExecutionContext build() {
+                return new ExecutionContext(this);
+            }
+        }
+    }
+
+    public static boolean execute(ExecutionContext context) {
+        Gender gender = context.gender;
+
+        if (gender.equals(Gender.CONSOLE)) {
+            return runConsoleCommand(context);
+        } else if (gender.equals(Gender.PLAYER)) {
+            return runPlayerCommand(context);
+        } else if (gender.equals(Gender.OPERATOR)) {
+            return runOperatorCommand(context);
+        } else if (gender.equals(Gender.CONSOLE_PER_USER)) {
+            return runConsolePerUserCommand(context);
+        } else if (gender.equals(Gender.CONSOLE_PER_USER_OFFLINE)) {
+            return runConsolePerUserOfflineCommand(context);
+        } else if (gender.equals(Gender.CONSOLE_PROXY)) {
+            return runConsoleProxyCommand(context);
+        }
+
+        return false;
+    }
+
+    private static boolean runConsoleCommand(ExecutionContext context) {
+        if (context.conditionChecker != null) {
+            Boolean valid = context.conditionChecker.apply(null);
+            if (valid == null || !valid) {
+                Messages.sendDebugConsole(CONDITION_NO_MATCH);
+                return false;
+            }
+        }
+
+        String command = context.command;
+        CommandTimerPlugin.getScheduler().runTask(() -> {
+            Bukkit.getServer().dispatchCommand(Bukkit.getConsoleSender(), PAPIHook.parsePAPI(command, null));
+            if (context.executionCounter != null) {
+                context.executionCounter.accept(1);
+            }
+        });
+        
+        if (context.onExecution != null) {
+            context.onExecution.run();
+        }
+        return true;
+    }
+
+    private static boolean runPlayerCommand(ExecutionContext context) {
+        String command = context.command;
+
+        Collection<Player> affectedPlayers = (Collection<Player>) Bukkit.getOnlinePlayers();
+        if (context.scopedPlayers != null && !context.scopedPlayers.isEmpty()) {
+            affectedPlayers = context.scopedPlayers.stream().map(Bukkit::getPlayer).filter(Objects::nonNull)
+                    .collect(Collectors.toList());
+        }
+
+        boolean delayedExecution = context.interval.toSeconds() > 0;
+        int i = 0;
+        boolean willExecute = false;
+        for (Player p : affectedPlayers) {
+            if (context.conditionChecker != null) {
+                Boolean valid = context.conditionChecker.apply((OfflinePlayer) p);
+                if (valid == null || !valid) {
+                    Messages.sendDebugConsole(CONDITION_NO_MATCH);
+                    continue;
+                }
+            }
+
+            willExecute = true;
+            if (delayedExecution) {
+                CommandTimerPlugin.getScheduler().runTaskLater(() -> runForPlayer(p, command, context),
+                        (20L * i * context.interval.toSeconds()) + 1);
+            } else {
+                runForPlayer(p, command, context);
+            }
+            i++;
+        }
+
+        return willExecute;
+    }
+
+    private static void runForPlayer(Player p, String command, ExecutionContext context) {
+        String parsedCommand = PAPIHook.parsePAPI(command, p);
+        CommandTimerPlugin.getScheduler().runTask(() -> {
+            boolean executed = p.performCommand(parsedCommand);
+
+            if (!executed) {
+                String errorMessage = new StringEnhancer("Failed to execute command {command}").add("command", command)
+                        .parse();
+                throw new CommandException(errorMessage);
+            }
+            if (context.executionCounter != null) {
+                context.executionCounter.accept(1);
+            }
+            if (context.onExecution != null) {
+                context.onExecution.run();
+            }
+        });
+    }
+
+    private static boolean runOperatorCommand(ExecutionContext context) {
+        String command = context.command;
+
+        Collection<Player> affectedPlayers = (Collection<Player>) Bukkit.getOnlinePlayers();
+        if (context.scopedPlayers != null && !context.scopedPlayers.isEmpty()) {
+            affectedPlayers = context.scopedPlayers.stream().map(Bukkit::getPlayer).filter(Objects::nonNull)
+                    .collect(Collectors.toList());
+        }
+
+        boolean delayedExecutions = context.interval.toSeconds() > 0;
+        int i = 0;
+        boolean willExecute = false;
+        for (Player p : affectedPlayers) {
+            boolean wasAlreadyOp = p.isOp();
+
+            try {
+                p.setOp(true);
+                if (context.conditionChecker != null) {
+                    Boolean valid = context.conditionChecker.apply((OfflinePlayer) p);
+                    if (valid == null || !valid) {
+                        Messages.sendDebugConsole(CONDITION_NO_MATCH);
+
+                        if (!wasAlreadyOp) {
+                            p.setOp(false);
+                        }
+                        continue;
+                    }
+                }
+                willExecute = true;
+
+                if (delayedExecutions) {
+                    CommandTimerPlugin.getScheduler().runTaskLater(() -> {
+                        p.performCommand(PAPIHook.parsePAPI(command, p));
+                        if (context.executionCounter != null) {
+                            context.executionCounter.accept(1);
+                        }
+                        if (context.onExecution != null) {
+                            context.onExecution.run();
+                        }
+                    }, (20L * i * context.interval.toSeconds()) + 1);
+                } else {
+                    CommandTimerPlugin.getScheduler().runTask(() -> {
+                        p.performCommand(PAPIHook.parsePAPI(command, p));
+                        if (context.executionCounter != null) {
+                            context.executionCounter.accept(1);
+                        }
+                        if (context.onExecution != null) {
+                            context.onExecution.run();
+                        }
+                    });
+                }
+
+            } finally {
+                if (!wasAlreadyOp) {
+                    p.setOp(false);
+                }
+            }
+            i++;
+        }
+
+        return willExecute;
+    }
+
+    private static boolean runConsolePerUserCommand(ExecutionContext context) {
+        String command = context.command;
+
+        Collection<Player> affectedPlayers = (Collection<Player>) Bukkit.getOnlinePlayers();
+        if (context.scopedPlayers != null && !context.scopedPlayers.isEmpty()) {
+            affectedPlayers = context.scopedPlayers.stream().map(Bukkit::getPlayer).filter(Objects::nonNull)
+                    .collect(Collectors.toList());
+        }
+
+        boolean delayedExecutions = context.interval.toSeconds() > 0;
+        int i = 0;
+        boolean willExecute = false;
+        for (Player p : affectedPlayers) {
+            if (context.conditionChecker != null) {
+                Boolean valid = context.conditionChecker.apply((OfflinePlayer) p);
+                if (valid == null || !valid) {
+                    Messages.sendDebugConsole(CONDITION_NO_MATCH);
+                    continue;
+                }
+            }
+            willExecute = true;
+
+            if (delayedExecutions) {
+                CommandTimerPlugin.getScheduler().runTaskLater(() -> {
+                    Bukkit.getServer().dispatchCommand(Bukkit.getConsoleSender(), PAPIHook.parsePAPI(command, p));
+                    if (context.executionCounter != null) {
+                        context.executionCounter.accept(1);
+                    }
+                    if (context.onExecution != null) {
+                        context.onExecution.run();
+                    }
+                }, (20L * i * context.interval.toSeconds()) + 1);
+            } else {
+                CommandTimerPlugin.getScheduler().runTask(() -> {
+                    Bukkit.getServer().dispatchCommand(Bukkit.getConsoleSender(), PAPIHook.parsePAPI(command, p));
+                    if (context.executionCounter != null) {
+                        context.executionCounter.accept(1);
+                    }
+                    if (context.onExecution != null) {
+                        context.onExecution.run();
+                    }
+                });
+            }
+            i++;
+        }
+
+        return willExecute;
+    }
+
+    private static boolean runConsolePerUserOfflineCommand(ExecutionContext context) {
+        String command = context.command;
+        boolean delayedExecutions = context.interval.toSeconds() > 0;
+
+        int i = 0;
+        for (OfflinePlayer p : Bukkit.getOfflinePlayers()) {
+            if (context.conditionChecker != null) {
+                Boolean valid = context.conditionChecker.apply(p);
+                if (valid == null || !valid) {
+                    Messages.sendDebugConsole(CONDITION_NO_MATCH);
+                    continue;
+                }
+            }
+            if (delayedExecutions) {
+                CommandTimerPlugin.getScheduler().runTaskLater(() -> {
+                    CommandTimerPlugin.getScheduler().runTask(() -> {
+                        Bukkit.getServer().dispatchCommand(Bukkit.getConsoleSender(), PAPIHook.parsePAPI(command, p));
+                        if (context.executionCounter != null) {
+                            context.executionCounter.accept(1);
+                        }
+                        if (context.onExecution != null) {
+                            context.onExecution.run();
+                        }
+                    });
+                }, (20L * i * context.interval.toSeconds()) + 1);
+            } else {
+                CommandTimerPlugin.getScheduler().runTask(() -> {
+                    Bukkit.getServer().dispatchCommand(Bukkit.getConsoleSender(), PAPIHook.parsePAPI(command, p));
+                    if (context.executionCounter != null) {
+                        context.executionCounter.accept(1);
+                    }
+                    if (context.onExecution != null) {
+                        context.onExecution.run();
+                    }
+                });
+            }
+            i++;
+        }
+
+        return true;
+    }
+
+    private static boolean runConsoleProxyCommand(ExecutionContext context) {
+        if (context.conditionChecker != null) {
+            Boolean valid = context.conditionChecker.apply(null);
+            if (valid == null || !valid) {
+                Messages.sendDebugConsole(CONDITION_NO_MATCH);
+                return false;
+            }
+        }
+
+        String command = context.command;
+        ByteArrayOutputStream b = new ByteArrayOutputStream();
+        DataOutputStream out = new DataOutputStream(b);
+        try {
+            out.writeUTF("executeConsoleCommand");
+            out.writeUTF(command);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        Bukkit.getServer().sendPluginMessage(CommandTimerPlugin.getPlugin(), "commandtimer:main", b.toByteArray());
+        if (context.executionCounter != null) {
+            context.executionCounter.accept(1);
+        }
+        if (context.onExecution != null) {
+            context.onExecution.run();
+        }
+        return true;
+    }
+}
+
diff --git a/src/main/java/me/playbosswar/com/utils/Files.java b/src/main/java/me/playbosswar/com/utils/Files.java
index 4f4472bc..9c960aaf 100644
--- a/src/main/java/me/playbosswar/com/utils/Files.java
+++ b/src/main/java/me/playbosswar/com/utils/Files.java
@@ -37,8 +37,10 @@ public class Files {
     public static void createDataFolders() {
         File timersFile = new File(pluginFolderPath + "/timers");
         File extensionsFolder = new File(pluginFolderPath + "/extensions");
+        File adHocCommandsFolder = new File(pluginFolderPath + "/ad-hoc-commands");
         timersFile.mkdirs();
         extensionsFolder.mkdirs();
+        adHocCommandsFolder.mkdirs();
 
         File dataFolder = CommandTimerPlugin.getPlugin().getDataFolder();
         File enLangFile = new File(dataFolder.getAbsoluteFile() + "/languages/en.json");
@@ -60,6 +62,14 @@ public static String getTaskLocalExecutionFile(UUID id) {
         return pluginFolderPath + "/timers/" + id + ".local.json";
     }
 
+    public static String getAdHocCommandsDirectory() {
+        return pluginFolderPath + "/ad-hoc-commands";
+    }
+
+    public static String getAdHocCommandFile(UUID id) {
+        return pluginFolderPath + "/ad-hoc-commands/" + id + ".json";
+    }
+
     private static void healTask(Task task) {
         TaskInterval defaultInterval = new TaskInterval(0, 0, 0, 5);
         if(task.getCommands() == null) {
diff --git a/src/main/java/me/playbosswar/com/utils/Messages.java b/src/main/java/me/playbosswar/com/utils/Messages.java
index 3cde029c..45988437 100644
--- a/src/main/java/me/playbosswar/com/utils/Messages.java
+++ b/src/main/java/me/playbosswar/com/utils/Messages.java
@@ -101,6 +101,8 @@ public static void sendHelpMessage(CommandSender sender) {
         Messages.sendMessage(sender, "§e/cmt activate <task> - §7Activate a task");
         Messages.sendMessage(sender, "§e/cmt deactivate <task> - §7Deactivate a task");
         Messages.sendMessage(sender, "§e/cmt execute <task> - §7Instantly execute a task");
+        Messages.sendMessage(sender, "§e/cmt nextexecutions <task> - §7Show next 10 executions for a task");
+        Messages.sendMessage(sender, "§e/cmt schedule [-after 1h10m5s] [-gender CONSOLE] <command> - §7Schedule a one-time command");
         Messages.sendMessage(sender, "§e/cmt reload - §7Reload the plugin");
         Messages.sendMessage(sender, "§e/cmt migrateToDatabase - §7Migrate JSON files to database");
     }
diff --git a/src/main/java/me/playbosswar/com/utils/TaskUtils.java b/src/main/java/me/playbosswar/com/utils/TaskUtils.java
deleted file mode 100644
index 03b05dc6..00000000
--- a/src/main/java/me/playbosswar/com/utils/TaskUtils.java
+++ /dev/null
@@ -1,42 +0,0 @@
-package me.playbosswar.com.utils;
-
-import me.playbosswar.com.tasks.Task;
-import org.bukkit.Bukkit;
-
-import java.time.DayOfWeek;
-import java.time.LocalDate;
-import java.util.List;
-import java.util.stream.Collectors;
-
-public class TaskUtils {
-    public static boolean checkTaskDaysContainToday(Task task) {
-        DayOfWeek today = LocalDate.now().getDayOfWeek();
-
-        return task.getDays().contains(today);
-    }
-
-    public static DayOfWeek getFirstNextDow(Task task) {
-        if(task.getDays().isEmpty()) {
-            return null;
-        }
-
-        List<Integer> dayValues = task.getDays().stream().map(DayOfWeek::getValue).collect(Collectors.toList());
-        DayOfWeek today = LocalDate.now().getDayOfWeek();
-        // Monday = 1, Sunday = 7
-        int todayValue = today.getValue();
-        int foundDay = -1;
-
-        while(foundDay == -1) {
-            if(dayValues.contains(todayValue)) {
-                foundDay = todayValue;
-            } else {
-                todayValue += 1;
-                if(todayValue > 7) {
-                    todayValue = 1;
-                }
-            }
-        }
-
-        return DayOfWeek.of(todayValue);
-    }
-}
diff --git a/src/main/java/me/playbosswar/com/utils/Tools.java b/src/main/java/me/playbosswar/com/utils/Tools.java
index fd1b6450..b2f0f51e 100644
--- a/src/main/java/me/playbosswar/com/utils/Tools.java
+++ b/src/main/java/me/playbosswar/com/utils/Tools.java
@@ -1,5 +1,6 @@
 package me.playbosswar.com.utils;
 
+import me.playbosswar.com.tasks.TaskInterval;
 import org.bukkit.World;
 import org.joda.time.Duration;
 import org.joda.time.Period;
@@ -114,4 +115,100 @@ public static String getTimeString(int seconds) {
 
         return getTenthNumeric(hours) + ":" + getTenthNumeric(minute) + ":" + getTenthNumeric(second);
     }
+
+    public static TaskInterval parseTimeString(String timeString) {
+        int days = 0;
+        int hours = 0;
+        int minutes = 0;
+        int seconds = 0;
+
+        String remaining = timeString.toLowerCase();
+        
+        if (remaining.contains("d")) {
+            int dIndex = remaining.indexOf("d");
+            int dEnd = dIndex;
+            while (dEnd > 0 && Character.isDigit(remaining.charAt(dEnd - 1))) {
+                dEnd--;
+            }
+            if (dEnd < dIndex) {
+                days = Integer.parseInt(remaining.substring(dEnd, dIndex));
+                remaining = remaining.substring(0, dEnd) + remaining.substring(dIndex + 1);
+            }
+        }
+        
+        if (remaining.contains("h")) {
+            int hIndex = remaining.indexOf("h");
+            int hEnd = hIndex;
+            while (hEnd > 0 && Character.isDigit(remaining.charAt(hEnd - 1))) {
+                hEnd--;
+            }
+            if (hEnd < hIndex) {
+                hours = Integer.parseInt(remaining.substring(hEnd, hIndex));
+                remaining = remaining.substring(0, hEnd) + remaining.substring(hIndex + 1);
+            }
+        }
+        
+        if (remaining.contains("m")) {
+            int mIndex = remaining.indexOf("m");
+            int mEnd = mIndex;
+            while (mEnd > 0 && Character.isDigit(remaining.charAt(mEnd - 1))) {
+                mEnd--;
+            }
+            if (mEnd < mIndex) {
+                minutes = Integer.parseInt(remaining.substring(mEnd, mIndex));
+                remaining = remaining.substring(0, mEnd) + remaining.substring(mIndex + 1);
+            }
+        }
+        
+        if (remaining.contains("s")) {
+            int sIndex = remaining.indexOf("s");
+            int sEnd = sIndex;
+            while (sEnd > 0 && Character.isDigit(remaining.charAt(sEnd - 1))) {
+                sEnd--;
+            }
+            if (sEnd < sIndex) {
+                seconds = Integer.parseInt(remaining.substring(sEnd, sIndex));
+            }
+        }
+
+        return new TaskInterval(days, hours, minutes, seconds);
+    }
+
+    public static ZonedDateTime getNextMinecraftTime(World world, LocalTime targetMcTime, int occurrence) {
+        long currentTicks = world.getTime();
+        long targetTicks = minecraftTimeToTicks(targetMcTime);
+
+        long ticksUntilTarget = targetTicks - currentTicks;
+        if (ticksUntilTarget < 0) {
+            ticksUntilTarget += 24000;
+        }
+
+        ticksUntilTarget += occurrence * 24000;
+
+        long realTimeSeconds = (long) (ticksUntilTarget * 0.05);
+        return ZonedDateTime.now().plusSeconds(realTimeSeconds);
+    }
+
+    public static LocalTime getMinecraftTimeAt(World world, ZonedDateTime realTime) {
+        long timeDiff = java.time.Duration.between(ZonedDateTime.now(), realTime).getSeconds();
+        long ticksDiff = (long) (timeDiff / 0.05);
+        long futureTicks = (world.getTime() + ticksDiff) % 24000;
+
+        long hours = (futureTicks / 1000 + 6) % 24;
+        long minutes = (futureTicks % 1000) * 60 / 1000;
+
+        return LocalTime.of((int) hours, (int) minutes);
+    }
+
+    public static long minecraftTimeToTicks(LocalTime mcTime) {
+        int hours = mcTime.getHour();
+        int minutes = mcTime.getMinute();
+
+        if (hours < 6) {
+            hours += 24;
+        }
+
+        long ticks = (hours - 6) * 1000L + (minutes * 1000L / 60);
+        return ticks % 24000;
+    }
 }
diff --git a/src/main/java/me/playbosswar/com/utils/gson/GsonConverter.java b/src/main/java/me/playbosswar/com/utils/gson/GsonConverter.java
index fecb7301..e618ca92 100644
--- a/src/main/java/me/playbosswar/com/utils/gson/GsonConverter.java
+++ b/src/main/java/me/playbosswar/com/utils/gson/GsonConverter.java
@@ -6,6 +6,7 @@
 import java.lang.reflect.Modifier;
 import java.lang.reflect.Type;
 import java.time.LocalTime;
+import java.time.ZonedDateTime;
 import java.util.Date;
 
 public class GsonConverter {
@@ -18,6 +19,7 @@ public GsonConverter() {
                 .setPrettyPrinting()
                 .registerTypeAdapter(Date.class, new GsonDate())
                 .registerTypeAdapter(LocalTime.class, new GsonLocalTime())
+                .registerTypeAdapter(ZonedDateTime.class, new GsonZonedDateTime())
                 .create();
     }
 
diff --git a/src/main/java/me/playbosswar/com/utils/gson/GsonZonedDateTime.java b/src/main/java/me/playbosswar/com/utils/gson/GsonZonedDateTime.java
new file mode 100644
index 00000000..101b40c3
--- /dev/null
+++ b/src/main/java/me/playbosswar/com/utils/gson/GsonZonedDateTime.java
@@ -0,0 +1,22 @@
+package me.playbosswar.com.utils.gson;
+
+import com.google.gson.*;
+
+import java.lang.reflect.Type;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+
+public class GsonZonedDateTime implements JsonSerializer<ZonedDateTime>, JsonDeserializer<ZonedDateTime> {
+
+    @Override
+    public ZonedDateTime deserialize(JsonElement jsonElement, Type type, JsonDeserializationContext jsonDeserializationContext) throws JsonParseException {
+        String zdtString = jsonElement.getAsString();
+        return ZonedDateTime.parse(zdtString, DateTimeFormatter.ISO_ZONED_DATE_TIME);
+    }
+
+    @Override
+    public JsonElement serialize(ZonedDateTime zonedDateTime, Type type, JsonSerializationContext jsonSerializationContext) {
+        return new JsonPrimitive(zonedDateTime.format(DateTimeFormatter.ISO_ZONED_DATE_TIME));
+    }
+}
+
diff --git a/src/main/resources/languages/default.json b/src/main/resources/languages/default.json
index 9fe4e905..55f33d1a 100644
--- a/src/main/resources/languages/default.json
+++ b/src/main/resources/languages/default.json
@@ -150,5 +150,16 @@
   "description_item": "&bDescription",
   "item_description_lore": "&7Description: &e$1",
   "description_lore": "\n&7Set the description for this command\n\n&7Current description: &e$1",
-  "description_conversation_input": "Enter your description:"
+  "description_conversation_input": "Enter your description:",
+  "scheduled_executions_gui_title": "&9&lScheduled Executions",
+  "scheduled_executions_item": "&bScheduled Executions",
+  "scheduled_executions_lore": "\n&7View all scheduled task executions\n&7that will be executed in the future",
+  "refresh_button_title": "&bRefresh",
+  "refresh_button_lore": "&7Click to refresh the list of\n&7scheduled executions",
+  "filter_button_title": "&bFilter",
+  "filter_button_lore": "&7Click to cycle through filters:\n&7  - All\n&7  - Tasks Only\n&7  - Ad-Hoc Only",
+  "filter_button_current": "&7Current filter: &e$1",
+  "filter_all": "All",
+  "filter_tasks_only": "Tasks Only",
+  "filter_adhoc_only": "Ad-Hoc Only"
 }
\ No newline at end of file
diff --git a/src/main/resources/languages/en.json b/src/main/resources/languages/en.json
index 9fe4e905..55f33d1a 100644
--- a/src/main/resources/languages/en.json
+++ b/src/main/resources/languages/en.json
@@ -150,5 +150,16 @@
   "description_item": "&bDescription",
   "item_description_lore": "&7Description: &e$1",
   "description_lore": "\n&7Set the description for this command\n\n&7Current description: &e$1",
-  "description_conversation_input": "Enter your description:"
+  "description_conversation_input": "Enter your description:",
+  "scheduled_executions_gui_title": "&9&lScheduled Executions",
+  "scheduled_executions_item": "&bScheduled Executions",
+  "scheduled_executions_lore": "\n&7View all scheduled task executions\n&7that will be executed in the future",
+  "refresh_button_title": "&bRefresh",
+  "refresh_button_lore": "&7Click to refresh the list of\n&7scheduled executions",
+  "filter_button_title": "&bFilter",
+  "filter_button_lore": "&7Click to cycle through filters:\n&7  - All\n&7  - Tasks Only\n&7  - Ad-Hoc Only",
+  "filter_button_current": "&7Current filter: &e$1",
+  "filter_all": "All",
+  "filter_tasks_only": "Tasks Only",
+  "filter_adhoc_only": "Ad-Hoc Only"
 }
\ No newline at end of file
diff --git a/src/main/resources/plugin.yml b/src/main/resources/plugin.yml
index 557eef70..55f7868c 100644
--- a/src/main/resources/plugin.yml
+++ b/src/main/resources/plugin.yml
@@ -1,6 +1,6 @@
 main: me.playbosswar.com.CommandTimerPlugin
 name: "CommandTimer"
-version: "8.14.1"
+version: "8.15.0"
 description: "Schedule commands like you want"
 author: PlayBossWar
 api-version: 1.13