//! # Fluent Command Line Interface (CLI) Application.
//!
//! This crate is the entry point for the Fluent CLI, enabling interaction with Flowise AI workflows
//! via the command line. The application handles all facets of user interaction, including parsing command-line
//! arguments, managing configurations, initializing logging features, and executing the core application logic.
//!
//! # Workflow
//!
//! The execution flow of the main function in `main.rs` is as follows:
//!
//! 1. **Command-line Parsing**: Utilizes the `CliOpts` struct from the `cli` module to parse the command-line
//!    arguments provided by the user.
//! 2. **Configuration Reading**: Reads the configuration file using `read_config` function from the `config` module.
//! 3. **Verbosity Calculation**: Determines the appropriate level of verbosity for logging by examining
//!    the `--quiet` and `--verbose` command-line options.
//! 4. **Logging Initialization**: Sets up logging based on the verbosity level using the `stderrlog` crate,
//!    and considers the `--timestamp` option if provided.
//! 5. **Shell Completions Generation**: If the `--generate-completions` flag is supplied, the application
//!    will generate completion scripts for the shell specified and then exit.
//! 6. **Application Execution**: Executes the core application logic by invoking the `run` function from the
//!    `app` module, with the parsed `CliOpts` passed as an argument.
//!
//! Errors encountered during these steps are handled using the `anyhow` crate which provides a convenient
//! way to return errors with context. Any errors will cause the application to terminate with a non-zero status code.
//!
//! # Modules
//!
//! This application is composed of multiple modules, each responsible for a distinct aspect of the functionality:
//!
//! - `app`: The nucleus of the application logic; includes functions related to configuration parsing, HTTP request
//!   formation, command-line option handling, and interpreting responses from AI workflows.
//! - `cli`: Houses the definitions for parsing command-line arguments, including the `CliOpts` struct.
//! - `config`: Focuses on accessing and parsing the application's configuration file.
//! - `http`: Defines abstractions for performing HTTP requests to the AI workflow services.
//! - `utils`: A collection of auxiliary functions for file manipulation, path operations, string processing, and more.
//! - `helpers`: Provides supplementary functions and constants essential throughout the application, including template
//!   helpers for the CLI interface.
//!
//! # Logging
//!
//! The logging is facilitated by the `stderrlog` crate which provides a simple logger configured via environment variables
//! and command-line options. It is set up to log to `stderr` with varying verbosity levels controlled by the user at runtime.
//!
//! # Panics
//!
//! Panics are a Rust mechanism for handling unexpected situations. This application is designed to avoid situations
//! that might cause panics and does not intentionally contain any code that would cause unwinding (panic! functionality).
//! The `panic = 'abort'` directive could potentially be enabled for release builds to reduce binary size at the cost of
//! panicking cleanup capabilities; the directive is currently commented out.
//!
//! # Error Handling
//!
//! Error handling is critically managed via the `anyhow` crate, which provides idiomatic ways of propagating errors.
//! If errors occur during the startup or running phases of the application, they will be returned and cause the binary to
//! exit with an error status code.
//!
//! # Safety
//!
//! This application takes Rust's safety guarantees seriously. As such, the use of `unsafe` code blocks is explicitly forbidden
//! through the `#![forbid(unsafe_code)]` attribute.
//!
//! # Compiler Directives
//!
//! The application uses several compiler directives (attributes) to maintain code quality and safety:
//!
//! - `warn(warnings, rust_2018_idioms)`: Enables certain compiler warnings to encourage idiomatic Rust code.
//! - `warn(clippy::all, clippy::pedantic, clippy::restriction)`: Enables various levels of Clippy lints which are checks
//!   for common mistakes and improvements for Rust code.
//! - `allow(clippy::float_arithmetic, clippy::implicit_return, clippy::needless_return)`: Disables specific Clippy lints
//!   that are overly pedantic for this project's scope.
//! - `forbid(unsafe_code)`: Prohibits the use of unsafe Rust code blocks within the application.
//!
//! # Features
//!
//! The `Cargo.toml` file specifies the application's metadata, dependencies, development dependencies, and build profiles.
//! Notable dependencies include `structopt`, `anyhow`, `tokio`, `clap`, among others, to handle asynchronous runtime, command-line
//! parsing, error handling, and HTTP requests. The `[profile.release]` section contains configuration to optimize the release
//! builds for size and performance.
//!
//! # Usage
//!
//! To run the Fluent CLI, you must first compile the application with Cargo, then you may use the following command to interact
//! with the application:
//!
//! ```
//! fluent [FLAGS] [OPTIONS]
//! ```
//!
//! Flags and options can be determined by running `fluent --help`.
//!
//! Please consult the specific module documentation for deeper insight into each module's responsibilities and usage.

//! Configuration module for the Fluent application.
//!
//! This module provides structures and functions for handling the various
//! configuration options available to the Fluent app. It allows the application
//! to manage different aspects of the configuration such as HTTP requests,
//! paths, regular expressions, defaults, styling, and skin configurations.
//! The configuration can be read from a JSON file whose path is specified via
//! an environment variable, and used to modify the behaviour of the application.

use anyhow::{Result, Context};
use serde::{Deserialize, Serialize};
use std::{fs};

use std::path::Path;

/// Structure representing the configuration for HTTP requests.
#[derive(Debug, Deserialize, Serialize)]
pub struct HttpRequestConfig {
    pub timeout: u64,
}

/// Structure representing different file paths used in the application.
#[derive(Debug, Deserialize, Serialize)]
pub struct PathsConfig {
    pub config_path: String,
}

/// Structure for regex pattern configuration.
#[derive(Debug, Deserialize, Serialize)]
pub struct RegexConfig {
    pub url_regex: String,
}

/// Structure for default configuration values.
#[derive(Debug, Deserialize, Serialize)]
pub struct DefaultsConfig {
    pub verbosity: u64,
}

/// Configuration for styling console output.
#[derive(Debug, Deserialize, Serialize)]
pub struct StylingConfig {
    pub error: String,
    pub success: String,
}

/// Configuration for customizing the appearance ("skin") of console output.
#[derive(Debug, Deserialize, Serialize)]
pub struct SkinConfig {
    pub headers_fg: String,
    pub bold_fg: String,
    pub italic_fg: String, // Added
    pub italic_bg: String, // Added
    pub bullet: String,
    pub bullet_char: char,
    pub quote_mark_fg: String, // Added
    pub code_block_margin: u8,
    pub code_block_align: String,
    pub code_block_bg: String,
    pub italic_attrs: Vec<String>,
    pub bold_attrs: Vec<String>, // Added
    pub bold_bg: String, // Added
    pub list_indent: u8, // Added
    pub list_start: String, // Added
    pub list_spacing: u8, // Added
    pub list_char: String, // Added
    pub list_margin: u8, // Added
    pub list_align: String, // Added
    pub list_bg: String, // Added
    pub list_fg: String, // Added
    pub list_padding: u8, // Added
    pub italic_fg_bg: Vec<String>,
    pub quote_mark: String,
}

/// Main configuration object that encapsulates all the settings.
#[derive(Debug, Deserialize, Serialize)]
pub struct Config {
    pub flows: Vec<Flow>,
    http_request: HttpRequestConfig,
    pub(crate) combined_input_format: String,
    pub(crate) processing_message: String,
    pub paths: PathsConfig,
    regex: RegexConfig,
    defaults: DefaultsConfig,
    styling: StylingConfig,
    pub(crate) skin_config: SkinConfig,
}

/// Represents the flow of operations, which includes HTTP requests and configuration overrides.
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct Flow {
    pub name: String,
    pub url: String,
    pub method: String,
    pub headers: serde_json::Value,
    #[serde(rename = "overrideConfig")]
    pub override_config: Option<serde_json::Value>,
}

/// Reads the configuration from a JSON file whose path is specified by the `FLUENT_CONFIG_PATH` environment variable.
///
/// # Errors
///
/// Returns an `Err` variant of `anyhow::Result` if:
/// - `FLUENT_CONFIG_PATH` environment variable is not set.
/// - The configuration file does not exist at the specified path.
/// - There is a failure reading the configuration file.
/// - There is an error parsing the JSON content into the `Config` structure.
///
/// # Examples
///
/// ```
/// let config = read_config().expect("Failed to read the configuration.");
/// ```
pub fn read_config() -> anyhow::Result<Config> {
    let config_path = std::env::var("FLUENT_CONFIG_PATH").expect("FLUENT_CONFIG_PATH environment variable is not set.");
    if !Path::new(&config_path).exists() {
        return Err(anyhow::anyhow!("Configuration file does not exist at {}", config_path));
    }

    let config_content = fs::read_to_string(&config_path)
        .with_context(|| format!("Failed to read config file at {}", config_path))?;

    match serde_json::from_str::<Config>(&config_content) {
        Ok(config) => {
            // Add a debug print or log here to inspect the loaded config
            //println!("Loaded config: {:?}", config);
            Ok(config)
        },
        Err(e) => {
            eprintln!("Failed to parse the configuration file: {}", e);
            // Directly print line and column information
            eprintln!("Error on line: {}, column: {}", e.line(), e.column());
            Err(e.into()) // Explicitly convert serde_json::Error into anyhow::Error
        }
    }
}

// Running Workflows
// Syntax for executing workflows
let opts = CliOpts::from_args();
let config = read_config()?;
let workflow = config.flows.iter().find(|f| f.name == opts.name).expect("Workflow not found");

// Passing parameters and inputs
let parameters = serde_json::to_value(opts.parameters)?;
let input = if let Some(input_path) = opts.input_path {
    std::fs::read_to_string(input_path)?
} else {
    String::new()
};

// Viewing and Interpreting Results
// Understanding output formats
let result = call_workflow(&workflow.url, &parameters, &input).await?;
println!("Workflow executed successfully. Result: {}", result);

// Handling errors and exceptions
if let Err(e) = call_workflow(&workflow.url, &parameters, &input).await {
    eprintln!("Error executing workflow: {}", e);
    std::process::exit(1);
}

// Generating shell completions
fn generate_bash_completion_script() -> io::Result<()> {
    // Retrieve the configuration path from the environment variable
    let config_path = env::var("FLUENT_CONFIG_PATH").unwrap_or_else(|_| "config.json".into());

    // Define the path to the bash completion script
    let script_path = PathBuf::from("fluent_cli_completion.sh");

    // Open a file to write the script
    let mut file = File::create(&script_path)?;

    // Start of the script
    writeln!(file, "#!/bin/bash")?;
    writeln!(file, "# Fluent CLI Bash Completion Script")?;
    writeln!(file, "# This script provides command line completion for Fluent CLI")?;
    writeln!(file, "#")?;
    writeln!(file, "# To use this script:")?;
    writeln!(file, "# 1. set the FLUENT_CONFIG_PATH environment variable")?;
    writeln!(file, "# 2. Make the script executable with 'chmod +x fluent_cli_completion.sh'")?;
    writeln!(file, "# 3. Source the script in your shell profile (e.g., .bashrc, .zshrc)")?;
    writeln!(file, "#    by adding the line: source /path/to/fluent_cli_completion.sh")?;
    writeln!(file, "#")?;
    writeln!(file, "# Autocompletion function")?;
    writeln!(file, "_fluent_cli_autocomplete() {{")?;
    writeln!(file, "    if [ \"$COMP_CWORD\" -eq 1 ]; then")?;
    // Use jq to extract flow names from the configuration file
    writeln!(file, "        FLOWS=$(jq -r '.flows[].name' \"{}\")", config_path)?;
    // Generate completion suggestions based on the flow names
    writeln!(file, "        COMPREPLY=($(compgen -W \"$FLOWS\" -- \"${{COMP_WORDS[COMP_CWORD]}}\"))")?;
    writeln!(file, "    fi")?;
    writeln!(file, "}}")?;
    writeln!(file, "")?;
    // Register the autocompletion function for the fluent-cli command
    writeln!(file, "complete -F _fluent_cli_autocomplete fluent-cli")?;

    println!("Bash completion script generated at: {:?}", script_path);
    println!("--------------------------------------------------------");
    println!("- Set the FLUENT_CONFIG_PATH environment variable, export FLUENT_CONFIG_PATH=location of your path to config.json");
    println!("- Make the script executable with 'chmod +x {:?}'", script_path);
    println!("- Then, source it in your shell profile (e.g., .bashrc, .zshrc) by adding:");
    println!("- source {:?}", script_path);
    println!("- Reload the shell (e.g., .bashrc, .zshrc) or restart your terminal");
    println!("- Type fluent and hit tab to see available the configured available flowiseAI worflows");

    Ok(())
}

async fn download_images_from_markdown(content: &str, destination_folder: &PathBuf) -> Result<()> {
    // Updated regex to match various image file extensions
    let image_url_regex = Regex::new(r"!\[[^\]]*\]\((https?://[^)]+\.(?:png|jpe?g|gif|svg|bmp|webp))\)").unwrap();

    for caps in image_url_regex.captures_iter(content) {
        let sanitized_name = sanitize_filename(content, 40);
        debug!("Sanitized name: {}", sanitized_name);
        if let Some(image_url) = caps.get(1).map(|m| m.as_str()) {
            debug!("Image URL: {}", image_url);
            let file_name = image_url.split('/').last().unwrap_or("image");
            debug!("File name: {}", file_name);
            let destination_path = destination_folder.join(format!("{}_{}", sanitized_name, file_name));
            debug!("downloading image from {} to {}", image_url, destination_path.display());

            // Download the image to the specified path
            if let Err(e) = download_image(image_url, &destination_path, &sanitized_name).await {
                debug!("Failed to download image from {}: {}", image_url, e);
            }
        }
    }

    Ok(())
}

fn parse_structured_response(json_response: Value) -> Result<String> {
    // Directly extract the "text" field which contains the Markdown content
    let extracted_text = json_response["text"].as_str().ok_or_else(|| anyhow!("No 'text' field found in JSON response"))?;

    // Extract the "text" field which contains the Markdown content
    // Step 2: Adjust the regex pattern to match code blocks of any language
    // The pattern now looks for ``` followed by any optional language identifier
    let code_block_pattern = Regex::new(r"(?s)```[a-zA-Z]*\s*\n(.*?)(?:\n```|$)")?;
    let mut extracted_code_blocks = Vec::new();

    // Iterate over all captures and collect the code blocks
    for cap in code_block_pattern.captures_iter(extracted_text) {
        if let Some(matched) = cap.get(1) {
            extracted_code_blocks.push(matched.as_str().trim().to_string());
        }
    }
    debug!("extracted code blocks: {:?}", extracted_code_blocks);
    if extracted_code_blocks.is_empty() {
        return Err(anyhow!("No code blocks found in Markdown content"));
    }

    // Step 3: Handle the Extracted Code Blocks
    // Join the extracted code blocks with two newlines as separator
    let concatenated_code_blocks = extracted_code_blocks.join("\n\n");
    Ok(concatenated_code_blocks)
}

//! # Security Considerations
//!
//! When using FluentCLI, it's crucial to ensure that sensitive information is protected and that
//! the tool is securely configured. Here are some best practices:
//!
//! ## Protecting Sensitive Information
//!
//! - Always use secure connections (HTTPS) when calling AI workflows to prevent eavesdropping.
//! - Store sensitive configuration details, such as API keys or tokens, in environment variables
//!   or secure configuration files with restricted access, rather than hardcoding them in scripts.
//! - Use the `--system-prompt-override` and `--system-prompt-override-file` options cautiously,
//!   ensuring that any dynamic content inserted into workflows does not expose sensitive information.
//!
//! ## Securely Configuring FluentCLI
//!
//! - Regularly update FluentCLI to the latest version to incorporate security fixes and improvements.
//! - Limit the permissions of the user running FluentCLI to only what is necessary for its operation.
//! - Review the configuration files and command-line options to ensure no unintended permissions or
//!   data exposures are configured.
//!
//! # Performance Optimization
//!
//! Efficient use of FluentCLI not only improves the performance of your workflows but also minimizes
//! resource usage, which is critical in production environments.
//!
//! ## Efficiently Configuring and Running Workflows
//!
//! - Optimize the configuration of your workflows by removing unnecessary steps or consolidating
//!   multiple operations where possible.
//! - Use the `--include-extra-data` flag judiciously to avoid sending unnecessary data in requests,
//!   which can increase processing time and bandwidth usage.
//!
//! ## Minimizing Resource Usage
//!
//! - When possible, batch process data with FluentCLI to reduce the overhead of initializing and
//!   tearing down workflow executions.
//! - Monitor the resource usage of FluentCLI and the underlying Flowise AI workflows to identify
//!   bottlenecks or areas for optimization, such as memory usage or network bandwidth.
//! - Consider the scalability of your infrastructure to ensure it can handle the load generated by
//!   FluentCLI, especially in high-demand scenarios.
//!
//! Implementing these best practices will help secure your FluentCLI usage and optimize its performance
//! and resource utilization.