mod actors;
mod config;
pub mod gitforge;
pub mod types;

use actix::prelude::*;

use kxio::network::Network;

use std::path::PathBuf;

use tracing::{error, info, level_filters::LevelFilter};

use crate::{
    fs::FileSystem,
    server::{
        actors::webhook,
        config::{ForgeConfig, ForgeName, GitDir, RepoAlias, ServerStorage, Webhook},
    },
};

use self::{actors::repo::RepoActor, config::ServerRepoConfig};

#[derive(Debug, derive_more::Display, derive_more::From)]
pub enum Error {
    #[display("Failed to create data directories")]
    FailedToCreateDataDirectory(kxio::fs::Error),

    #[display("The forge data path is not a directory: {path:?}")]
    ForgeDirIsNotDirectory {
        path: PathBuf,
    },

    Config(crate::server::config::Error),

    Io(std::io::Error),
}
type Result<T> = core::result::Result<T, Error>;

pub fn init(fs: FileSystem) {
    let file_name = "git-next-server.toml";
    let pathbuf = PathBuf::from(file_name);
    let Ok(exists) = fs.path_exists(&pathbuf) else {
        eprintln!("Could not check if file exist: {}", file_name);
        return;
    };
    if exists {
        eprintln!(
            "The configuration file already exists at {} - not overwritting it.",
            file_name
        );
    } else {
        match fs.file_write(&pathbuf, include_str!("../../server-default.toml")) {
            Ok(_) => println!("Created a default configuration file at {}", file_name),
            Err(e) => {
                eprintln!("Failed to write to the configuration file: {}", e)
            }
        }
    }
}

pub async fn start(fs: FileSystem, net: Network) {
    init_logging();
    info!("Starting Server...");
    let server_config = match config::ServerConfig::load(&fs) {
        Ok(server_config) => server_config,
        Err(err) => {
            error!("Failed to load config file. Error: {}", err);
            return;
        }
    };
    // create data dir if missing
    let dir = server_config.storage().path();
    if !dir.exists() {
        if let Err(err) = fs.dir_create(dir) {
            error!(?err, ?dir, "Failed to create server storage directory");
            return;
        }
    }

    let webhook_router = webhook::WebhookRouter::new().start();
    let webhook = server_config.webhook();
    let server_storage = server_config.storage();

    if let Err(err) = create_forge_data_directories(&server_config, &fs, &dir) {
        error!(?err, "Failure creating forge data directories");
        return;
    }

    for (forge_name, forge_config) in server_config.forges() {
        create_forge_repos(
            forge_config,
            forge_name.clone(),
            server_storage,
            webhook,
            &net,
        )
        .into_iter()
        .map(start_actor)
        .map(|(alias, addr)| webhook::AddWebhookRecipient(alias, addr.recipient()))
        .for_each(|msg| webhook_router.do_send(msg));
    }
    let webhook_server = webhook::WebhookActor::new(webhook_router.recipient()).start();
    let _ = actix_rt::signal::ctrl_c().await;
    info!("Ctrl-C received, shutting down...");
    drop(webhook_server);
}

fn create_forge_data_directories(
    server_config: &config::ServerConfig,
    fs: &FileSystem,
    server_dir: &&std::path::Path,
) -> Result<()> {
    for (forge_name, _forge_config) in server_config.forges() {
        let forge_dir: PathBuf = (&forge_name).into();
        let path = server_dir.join(&forge_dir);
        if fs.path_exists(&path)? {
            if !fs.path_is_dir(&path)? {
                return Err(Error::ForgeDirIsNotDirectory { path });
            }
        } else {
            fs.dir_create_all(&path)?;
        }
    }

    Ok(())
}

fn create_forge_repos(
    forge_config: &ForgeConfig,
    forge_name: ForgeName,
    server_storage: &ServerStorage,
    webhook: &Webhook,
    net: &Network,
) -> Vec<(ForgeName, RepoAlias, RepoActor)> {
    let span = tracing::info_span!("Forge", %forge_name, %forge_config);
    let _guard = span.enter();
    info!("Creating Forge");
    let mut repos = vec![];
    let creator = create_actor(
        forge_name,
        forge_config.clone(),
        server_storage,
        webhook,
        net,
    );
    for (repo_alias, server_repo_config) in forge_config.repos() {
        let forge_repo = creator((repo_alias, server_repo_config));
        info!(
            forge = %forge_repo.0,
            alias = %forge_repo.1,
            "created forge repo"
        );
        repos.push(forge_repo);
    }
    repos
}

fn create_actor(
    forge_name: ForgeName,
    forge_config: config::ForgeConfig,
    server_storage: &ServerStorage,
    webhook: &Webhook,
    net: &Network,
) -> impl Fn((RepoAlias, &ServerRepoConfig)) -> (ForgeName, RepoAlias, RepoActor) {
    let server_storage = server_storage.clone();
    let webhook = webhook.clone();
    let net = net.clone();
    move |(repo_name, server_repo_config)| {
        let span = tracing::info_span!("Repo", %repo_name, %server_repo_config);
        let _guard = span.enter();
        info!("Creating Repo");
        let gitdir = server_repo_config.gitdir().map_or_else(
            || {
                GitDir::from(
                    server_storage
                        .path()
                        .join(forge_name.to_string())
                        .join(repo_name.to_string()),
                )
            },
            |gitdir| gitdir,
        );
        // INFO: can't canonicalise gitdir as the path needs to exist to do that and we may not
        //       have cloned the repo yet
        let repo_details = config::RepoDetails::new(
            &repo_name,
            server_repo_config,
            &forge_name,
            &forge_config,
            gitdir,
        );
        let actor = actors::repo::RepoActor::new(repo_details, webhook.clone(), net.clone());
        info!("Created Repo");
        (forge_name.clone(), repo_name, actor)
    }
}

fn start_actor(
    actor: (ForgeName, RepoAlias, actors::repo::RepoActor),
) -> (RepoAlias, Addr<actors::repo::RepoActor>) {
    let (forge_name, repo_alias, actor) = actor;
    let span = tracing::info_span!("Forge/Repo", %forge_name, %repo_alias);
    let _guard = span.enter();
    info!("Starting");
    let addr = actor.start();
    addr.do_send(actors::repo::CloneRepo);
    info!("Started");
    (repo_alias, addr)
}

pub fn init_logging() {
    use tracing_subscriber::prelude::*;

    let subscriber = tracing_subscriber::fmt::layer()
        // NOTE: set RUSTLOG in ${root}/.cargo/config
        .with_target(false)
        .with_file(true)
        .with_line_number(true)
        .with_filter(LevelFilter::INFO);
    tracing_subscriber::registry()
        .with(console_subscriber::ConsoleLayer::builder().spawn())
        .with(subscriber)
        .init();
}