//! Payphone is a Discord bot that allows users to make calls to each other, similar to a phone
//! system.
//!
//! # Setting Up
//!
//! First of all, clone the Git repository and navigate to the project directory:
//!
//! ```shell
//! $ git clone --branch rewrite https://git.nyeki.dev/payphone/payphone.git
//! $ cd payphone
//! ```
//!
//! To boot up Payphone, you'll need both a Discord bot token and  a Scylla database cluster with
//! at least 3 nodes.
//!
//! - To get a Discord bot token, create a new bot application on the
//!   [Discord Developer Portal](https://discord.com/developers/applications).
//!
//! - To set up a Scylla database cluster, make sure to have Docker and Docker Compose installed
//!   and run `docker compose up -d`. A development cluster will be created with 3 nodes, with one
//!   of them listening at `127.0.0.1:9042`.
//!
//! To stop the database cluster at any time, run `docker compose down`. To stop it and delete the
//! volumes (resetting the database), run `docker compose down -v`.
//!
//! ## Booting Up
//!
//! Payphone has a CLI interface that allows you to pass the bot token and database URL as CLI
//! arguments. To get all possible arguments, run the following command:
//!
//! ```shell
//! $ cargo run -- --help
//! ```
//!
//! Payphone also supports configuration via environment variables and `.env` files by default.
//!
//! ```env
//! PAYPHONE_TOKEN="your_discord_bot_token"
//! ```
//!
//! All environment variables are prefixed with `PAYPHONE_` and can be used to override the CLI
//! arguments.
//!
//! # Framework
//!
//! Payphone has a custom framework that allows you to create commands, components, and event
//! handlers easily. The framework is designed to be modular and extensible, allowing you to add
//! new features and commands without modifying the core codebase. The documentation for the
//! framework is all in the [`framework`] module.
//!
//! # Database
//!
//! The database Payphone runs on is ScyllaDB, a high-performance NoSQL database compatible with
//! Apache Cassandra. For documentation on how to interact with the database, check the
//! [`database`] module's documentation.
//!
//! # Application Code
//!
//! Payphone's application code is under the [`groups`] module. It contains all commands, events,
//! embeds, and other configurations for the bot grouped in submodules (e.g. [`groups::calls`],
//! [`groups::about`], etc.), all which can be found at the [`groups`] module's documentation.
//!
//! Each submodule contains files like `commands.rs`, `events.rs`, `embeds.rs`, and `components.rs`
//! that define the commands, events, embeds, and components for that group. Some common file names
//! are:
//!
//! - `commands.rs`: Contains the commands for the group.
//! - `events.rs`: Contains the event handlers for the group.
//! - `embeds.rs`: Contains the embeds for the group.
//! - `components.rs`: Contains the components for the group (action rows, buttons, soon also
//!   select menus).
//!
//! Always try to follow the same structure and patterns as the existing code to maintain
//! consistency and readability.
//!
//! More documentation about each group can be found in the respective submodule's documentation.

use std::{net::SocketAddr, path::Path, process::Command, sync::mpsc};

use axum::{Router, response::Redirect, routing};
use clap::Parser;
use notify::{Event, EventKind, Watcher};
use tokio::net::TcpListener;
use tower_http::services::ServeDir;
use twilight_gateway::Intents;

use crate::{
    cli::{Args, Commands},
    framework::bot::Bot,
    groups::{
        about::{commands::HelpCommand, components::HelpGoBackButton},
        calls::{
            commands::{CallCommand, HangupCommand},
            events::MessageRedirector,
        },
        gateway::events::{ReadyHandler, ReconnectHandler},
        servers::events::{ServerCreateHandler, ServerDeleteHandler, ServerUpdateHandler},
    },
    state::State,
};

mod cli;
mod constants;
mod database;
mod discord;
mod framework;
mod groups;
mod logging;
mod state;
mod utils;

#[tokio::main]
pub async fn main() {
    dotenvy::dotenv().ok();

    let args = Args::parse();

    logging::init(args.logging.into());

    if let Some(command) = args.command {
        match command {
            Commands::Start {
                token,
                database_addr,
            } => {
                start(token, database_addr).await;
            }
            Commands::Docs { port } => {
                docs(port).await;
            }
        }
    }
}

async fn start(token: String, database_addr: String) {
    log::info!("Welcome to Payphone, Nyeki!");
    log::info!(
        "Payphone is running on version v{}",
        env!("CARGO_PKG_VERSION")
    );

    let db = database::init(database_addr)
        .await
        .expect("Could not connect to the database!");

    log::info!("Database connection established successfully!");

    let state = State { db };

    let bot = Bot::new(state, ["p."])
        .intent(Intents::GUILDS)
        .intent(Intents::GUILD_MESSAGES)
        .intent(Intents::MESSAGE_CONTENT)
        .command(HelpCommand)
        .command(CallCommand::new())
        .command(HangupCommand)
        .component(HelpGoBackButton)
        .on_ready(ReadyHandler)
        .on_reconnect(ReconnectHandler)
        .on_message(MessageRedirector)
        .on_server_create(ServerCreateHandler)
        .on_server_update(ServerUpdateHandler)
        .on_server_delete(ServerDeleteHandler);

    bot.run(&token).await.expect("Could not run bot!");
}

async fn docs(port: u16) {
    log::info!("Compiling documentation...");

    Command::new("cargo")
        .args(["doc", "--no-deps"])
        .output()
        .expect("Failed to run `cargo doc`");

    tokio::spawn(async {
        let (tx, rx) = mpsc::channel::<notify::Result<Event>>();

        let mut watcher = notify::recommended_watcher(tx).expect("Failed to create watcher");

        watcher
            .watch(Path::new("src/"), notify::RecursiveMode::Recursive)
            .expect("Failed to watch src directory");

        for res in rx {
            match res {
                Ok(event) => {
                    match event.kind {
                        EventKind::Create(_) | EventKind::Modify(_) | EventKind::Remove(_) => {
                            log::info!("Source files changed, recompiling...");
                        }
                        _ => continue,
                    }

                    Command::new("cargo")
                        .args(["doc", "--no-deps"])
                        .output()
                        .expect("Failed to run `cargo doc`");
                }
                Err(e) => {
                    log::error!("Watch error: {e:?}");
                }
            }
        }
    });

    log::info!("Starting documentation server on port {port}...");

    let docs: Router<()> = Router::new()
        .route(
            "/",
            routing::get(|| async { Redirect::permanent("/payphone/") }),
        )
        .fallback_service(ServeDir::new(concat!(
            env!("CARGO_MANIFEST_DIR"),
            "/target/doc/"
        )));

    let listener = TcpListener::bind(SocketAddr::from(([0, 0, 0, 0], port)))
        .await
        .expect("Could not bind to port!");

    log::info!("Documentation server is running on http://localhost:{port}/");

    axum::serve(listener, docs)
        .await
        .expect("Could not start documentation server!");
}