use dotenvy::dotenv;
use telers::{
    enums::ContentType,
    event::ToServiceProvider,
    filters::{content_type::ContentType as CT, Command},
    Bot, Dispatcher, Router,
};

use tracing_subscriber::{fmt, layer::SubscriberExt as _, util::SubscriberInitExt as _, EnvFilter};

mod middlewares;
mod types;
mod utils;

use middlewares::admin_check_middleware::AdminCheck;

mod handlers;
use handlers::{
    commands_handler::{help_command::help, unmute_command::unmute_command},
    dice_handler::dice::dice_handler,
};

#[tokio::main]
async fn main() {
    tracing_subscriber::registry()
        .with(fmt::layer())
        .with(EnvFilter::from_env("RUST_LOG"))
        .init();

    dotenv().ok();

    let token_result = dotenvy::var("TOKEN");
    match token_result {
        Ok(token) => {
            let bot = Bot::new(token);

            let mut route = Router::new("main");

            let mut dice = Router::new("dice");

            dice.message
                .register(dice_handler)
                .filter(CT::one(ContentType::Dice));

            dice.message.inner_middlewares.register(AdminCheck {});

            let mut command = Router::new("commands");
            let mut admin_commands = Router::new("admin_commands");
            let mut default_commands = Router::new("default_commands");

            admin_commands
                .message
                .register(unmute_command)
                .filter(Command::one("unmute"));

            admin_commands
                .message
                .inner_middlewares
                .register(AdminCheck {});

            default_commands
                .message
                .register(help)
                .filter(Command::one("help"));

            command.include(admin_commands).include(default_commands);

            route.include(dice).include(command);

            let dispatcher = Dispatcher::builder().main_router(route).bot(bot).build();

            dispatcher
                .to_service_provider_default()
                .unwrap()
                .run_polling()
                .await
                .unwrap();
        }
        Err(error) => {
            println!("Error text: {:?}", error);
        }
    }
}