ordinary 0.8.0

// Copyright (C) 2026 Ordinary Labs, LLC.
//
// SPDX-License-Identifier: AGPL-3.0-only

use crate::cmds::accounts::get_current_account;
use crate::cmds::logs::{Logs, Sync, print_logs_metadata_table};
use anyhow::bail;
use clap::Subcommand;
use clio::ClioPath;
use ordinary_api::client::OrdinaryApiClient;
use ordinary_build::traverse;
use ordinary_config::OrdinaryConfig;
use std::path::Path;

#[derive(Subcommand, Debug)]
pub enum App {
    /// deploy a changes to ordinary.json
    Deploy {
        /// whether the result of the operation should be
        /// printed to stdout formatted as JSON
        #[arg(short, long, default_value_t = false)]
        json_to_stdout: bool,

        /// overrides if mode=production. does nothing if mode is localhost or staging
        ///
        /// useful for when you're validating that your DNS is configured properly, and you
        /// want to avoid the Let's Encrypt rate limit for production mode <https://letsencrypt.org/docs/rate-limits/>
        #[arg(short, long, default_value_t = false)]
        tls_staging: bool,
    },
    /// push a configuration change which will
    /// modify the shape of your data stores
    ///
    /// (i.e. a structural change to model or content definitions)
    Migrate,
    // /// request the current host "bridge" with an additional
    // /// `ordinaryd` instance, in order to run your application
    // /// across two hosts.
    // Bridge {
    //     /// url for another `ordinaryd` instance
    //     remote: String,
    // },
    /// kill a running instance of the application
    Kill,
    /// restart a running instance of the application
    Restart {
        /// whether the result of the operation should be
        /// printed to stdout formatted as JSON
        #[arg(short, long, default_value_t = false)]
        json_to_stdout: bool,

        /// overrides if mode=production. does nothing if mode is localhost or staging
        ///
        /// useful for when you're validating that your DNS is configured properly, and you
        /// want to avoid the Let's Encrypt rate limit for production mode <https://letsencrypt.org/docs/rate-limits/>
        #[arg(short, long, default_value_t = false)]
        tls_staging: bool,
    },
    /// fully erase all content of the application from the host
    Erase,
    /// download an application as static files
    Download {
        /// url override. will use project domain by default
        #[arg(short, long)]
        url: Option<String>,
        /// where to store downloaded files
        #[arg(short, long, value_parser = clap::value_parser!(ClioPath).exists().is_dir(), default_value = "out")]
        out: ClioPath,
    },
    /// query application logs
    Logs {
        #[command(subcommand)]
        logs: Logs,
    },
    /// manage application accounts
    Accounts {
        #[command(subcommand)]
        accounts: Accounts,
    },
    /// list all HTTP routes
    Routes,
}

#[derive(Subcommand, Debug)]
pub enum Accounts {
    /// list application accounts
    List,
}

impl App {
    #[allow(clippy::missing_panics_doc, clippy::too_many_lines)]
    pub async fn handle(
        &self,
        api_domain: Option<&str>,
        accept_invalid_certs: bool,
        project: &str,
        insecure: bool,
    ) -> anyhow::Result<()> {
        let account = get_current_account(insecure)?;
        let client = OrdinaryApiClient::new(
            &account.host,
            &account.name,
            api_domain,
            accept_invalid_certs,
            crate::USER_AGENT,
            false,
        )?;

        match self {
            Self::Deploy {
                json_to_stdout,
                tls_staging,
            } => {
                let ports_res = client.deploy(project, *tls_staging).await?;
                tracing::info!("app deployed");

                if *json_to_stdout {
                    println!("{}", serde_json::to_string(&ports_res)?);
                }
            }
            Self::Migrate => {
                println!("todo: migrate");
            }
            // Self::Bridge { remote } => {
            //     tracing::info!("todo: bridge {project} to {remote}");
            // }
            Self::Kill => {
                client.kill(project).await?;
            }
            Self::Restart {
                json_to_stdout,
                tls_staging,
            } => {
                let ports_res = client.restart(project, *tls_staging).await?;
                tracing::info!("app restarted");

                if *json_to_stdout {
                    println!("{}", serde_json::to_string(&ports_res)?);
                }
            }
            Self::Erase => {
                client.erase(project).await?;
            }
            Self::Download { url, out } => {
                let out = out.to_str().expect("failed to convert to string");

                if let Some(url) = url {
                    ordinary_download::download(project, url, out).await?;
                } else {
                    ordinary_download::download(
                        project,
                        &format!("https://{}", account.project),
                        out,
                    )
                    .await?;
                }
            }
            Self::Logs { logs } => match logs {
                Logs::Search {
                    format,
                    query,
                    limit,
                    sync,
                } => {
                    if sync == &Some(true) {
                        client.app_logs_sync(project, None, None).await?;
                    }

                    let res = client.app_logs_search(project, query, format.as_str(), limit)?;

                    print!("{res}");
                }
                Logs::Sync { sync } => match sync {
                    Sync::Info => {
                        let remote_metadata = client.app_logs_remote_metadata(project).await?;
                        let local_metadata = client.app_logs_local_metadata(project)?;

                        print_logs_metadata_table(remote_metadata, local_metadata);
                    }
                    Sync::All { force } => {
                        client.app_logs_sync(project, *force, None).await?;
                    }
                    Sync::File { name } => {
                        client.app_logs_sync(project, None, Some(name)).await?;
                    }
                },
            },
            Self::Accounts { accounts } => match accounts {
                Accounts::List => {
                    let res = client.app_accounts_list(project).await?;

                    print!("{res}");
                }
            },
            Self::Routes => {
                let config = OrdinaryConfig::get(project)?;

                println!("ROUTES\n");

                if let Some(assets) = config.assets {
                    let Some(assets_dir_path) = &assets.dir_path else {
                        bail!("assets.dir_path cannot be unset");
                    };

                    println!("assets:");

                    let base_route = assets.base_route.as_str();
                    let assets_dir = Path::new(project).join(assets_dir_path);

                    traverse(&assets_dir, &|entry| {
                        let path = entry.path();
                        let path = path.strip_prefix(&assets_dir)?;

                        if base_route == "/" {
                            println!("- GET /{}", path.display());
                        } else {
                            println!("- GET {base_route}/{}", path.display());
                        }

                        Ok(())
                    })?;

                    println!();
                }

                if let Some(templates) = config.templates {
                    println!("templates:");

                    for template in templates {
                        println!("- GET {}", template.route);
                    }

                    println!();
                }

                if let Some(redirects) = config.redirects
                    && let Some(redirects) = redirects.route
                {
                    println!("redirects:");

                    for redirect in redirects {
                        println!(
                            "- {} {} [ {} -> {} ]",
                            redirect.method, redirect.condition, redirect.rule.0, redirect.rule.1
                        );
                    }

                    println!();
                }

                if let Some(proxies) = config.proxies {
                    println!("proxies:");

                    for proxy in proxies {
                        if let Some(path) = proxy.path {
                            println!("- ANY {path} -> {}", proxy.target);
                        } else if let Some(domain) = proxy.domain {
                            println!("- ANY http(s)://{domain}/{{*path}} -> {}", proxy.target);
                        }
                    }

                    println!();
                }
            }
        }

        Ok(())
    }
}