//! Rhai wrappers for Nerdctl module functions
//!
//! This module provides Rhai wrappers for the functions in the Nerdctl module.

use crate::nerdctl::{self, Container, HealthCheck, Image, NerdctlError};
use rhai::{Array, Dynamic, Engine, EvalAltResult, Map};
use sal_process::CommandResult;

// Helper functions for error conversion with improved context
fn nerdctl_error_to_rhai_error<T>(
    result: Result<T, NerdctlError>,
) -> Result<T, Box<EvalAltResult>> {
    result.map_err(|e| {
        // Create a more detailed error message based on the error type
        let error_message = match &e {
            NerdctlError::CommandExecutionFailed(io_err) => {
                format!("Failed to execute nerdctl command: {}. This may indicate nerdctl is not installed or not in PATH.", io_err)
            },
            NerdctlError::CommandFailed(msg) => {
                format!("Nerdctl command failed: {}. Check container status and logs for more details.", msg)
            },
            NerdctlError::JsonParseError(msg) => {
                format!("Failed to parse nerdctl JSON output: {}. This may indicate an incompatible nerdctl version.", msg)
            },
            NerdctlError::ConversionError(msg) => {
                format!("Data conversion error: {}. This may indicate unexpected output format from nerdctl.", msg)
            },
            NerdctlError::Other(msg) => {
                format!("Nerdctl error: {}. This is an unexpected error.", msg)
            },
        };
        Box::new(EvalAltResult::ErrorRuntime(
            error_message.into(),
            rhai::Position::NONE
        ))
    })
}

//
// Container Builder Pattern Implementation
//

/// Create a new Container
pub fn container_new(name: &str) -> Result<Container, Box<EvalAltResult>> {
    nerdctl_error_to_rhai_error(Container::new(name))
}

/// Create a Container from an image
pub fn container_from_image(name: &str, image: &str) -> Result<Container, Box<EvalAltResult>> {
    nerdctl_error_to_rhai_error(Container::from_image(name, image))
}

/// Reset the container configuration to defaults while keeping the name and image
pub fn container_reset(container: Container) -> Container {
    container.reset()
}

// TODO: remove?
/// Set health check with options for a Container
pub fn container_with_health_check_options(
    container: Container,
    cmd: &str,
    interval: Option<&str>,
    timeout: Option<&str>,
    retries: Option<i64>,
    start_period: Option<&str>,
) -> Container {
    // Convert i64 to u32 for retries
    let retries_u32 = retries.map(|r| r as u32);
    container.with_health_check_options(cmd, interval, timeout, retries_u32, start_period)
}

/// Build and run the Container
///
/// This function builds and runs the container using the configured options.
/// It provides detailed error information if the build fails.
pub fn container_build(container: Container) -> Result<Container, Box<EvalAltResult>> {
    // Get container details for better error reporting
    let container_name = container.name.clone();
    let image = container
        .image
        .clone()
        .unwrap_or_else(|| "none".to_string());
    let ports = container.ports.clone();
    let volumes = container.volumes.clone();
    let env_vars = container.env_vars.clone();

    // Try to build the container
    let build_result = container.build();

    // Handle the result with improved error context
    match build_result {
        Ok(built_container) => {
            // Container built successfully
            Ok(built_container)
        }
        Err(err) => {
            // Add more context to the error
            let enhanced_error = match err {
                NerdctlError::CommandFailed(msg) => {
                    // Provide more detailed error information
                    let mut enhanced_msg = format!(
                        "Failed to build container '{}' from image '{}': {}",
                        container_name, image, msg
                    );

                    // Add information about configured options that might be relevant
                    if !ports.is_empty() {
                        enhanced_msg.push_str(&format!("\nConfigured ports: {:?}", ports));
                    }

                    if !volumes.is_empty() {
                        enhanced_msg.push_str(&format!("\nConfigured volumes: {:?}", volumes));
                    }

                    if !env_vars.is_empty() {
                        enhanced_msg.push_str(&format!(
                            "\nConfigured environment variables: {:?}",
                            env_vars
                        ));
                    }

                    // Add suggestions for common issues
                    if msg.contains("not found") || msg.contains("no such image") {
                        enhanced_msg.push_str("\nSuggestion: The specified image may not exist or may not be pulled yet. Try pulling the image first with nerdctl_image_pull().");
                    } else if msg.contains("port is already allocated") {
                        enhanced_msg.push_str("\nSuggestion: One of the specified ports is already in use. Try using a different port or stopping the container using that port.");
                    } else if msg.contains("permission denied") {
                        enhanced_msg.push_str("\nSuggestion: Permission issues detected. Check if you have the necessary permissions to create containers or access the specified volumes.");
                    }

                    NerdctlError::CommandFailed(enhanced_msg)
                }
                _ => err,
            };

            nerdctl_error_to_rhai_error(Err(enhanced_error))
        }
    }
}

/// Start the Container and verify it's running
///
/// This function starts the container and verifies that it's actually running.
/// It returns detailed error information if the container fails to start or
/// if it starts but stops immediately.
pub fn container_start(container: &mut Container) -> Result<CommandResult, Box<EvalAltResult>> {
    // Get container details for better error reporting
    let container_name = container.name.clone();
    let container_id = container
        .container_id
        .clone()
        .unwrap_or_else(|| "unknown".to_string());

    // Try to start the container
    let start_result = container.start();

    // Handle the result with improved error context
    match start_result {
        Ok(result) => {
            // Container started successfully
            Ok(result)
        }
        Err(err) => {
            // Add more context to the error
            let enhanced_error = match err {
                NerdctlError::CommandFailed(msg) => {
                    // Check if this is a "container already running" error, which is not really an error
                    if msg.contains("already running") {
                        return Ok(CommandResult {
                            stdout: format!("Container {} is already running", container_name),
                            stderr: "".to_string(),
                            success: true,
                            code: 0,
                        });
                    }

                    // Try to get more information about why the container might have failed to start
                    let mut enhanced_msg = format!(
                        "Failed to start container '{}' (ID: {}): {}",
                        container_name, container_id, msg
                    );

                    // Try to check if the image exists
                    if let Some(image) = &container.image {
                        enhanced_msg.push_str(&format!("\nContainer was using image: {}", image));
                    }

                    NerdctlError::CommandFailed(enhanced_msg)
                }
                _ => err,
            };

            nerdctl_error_to_rhai_error(Err(enhanced_error))
        }
    }
}

/// Stop the Container
pub fn container_stop(container: &mut Container) -> Result<CommandResult, Box<EvalAltResult>> {
    nerdctl_error_to_rhai_error(container.stop())
}

/// Remove the Container
pub fn container_remove(container: &mut Container) -> Result<CommandResult, Box<EvalAltResult>> {
    nerdctl_error_to_rhai_error(container.remove())
}

/// Execute a command in the Container
pub fn container_exec(
    container: &mut Container,
    command: &str,
) -> Result<CommandResult, Box<EvalAltResult>> {
    nerdctl_error_to_rhai_error(container.exec(command))
}

/// Get container logs
pub fn container_logs(container: &mut Container) -> Result<CommandResult, Box<EvalAltResult>> {
    // Get container details for better error reporting
    let container_name = container.name.clone();
    let container_id = container
        .container_id
        .clone()
        .unwrap_or_else(|| "unknown".to_string());

    // Use the nerdctl::logs function
    let logs_result = nerdctl::logs(&container_id);

    match logs_result {
        Ok(result) => Ok(result),
        Err(err) => {
            // Add more context to the error
            let enhanced_error = NerdctlError::CommandFailed(format!(
                "Failed to get logs for container '{}' (ID: {}): {}",
                container_name, container_id, err
            ));

            nerdctl_error_to_rhai_error(Err(enhanced_error))
        }
    }
}

/// Copy files between the Container and local filesystem
pub fn container_copy(
    container: &mut Container,
    source: &str,
    dest: &str,
) -> Result<CommandResult, Box<EvalAltResult>> {
    nerdctl_error_to_rhai_error(container.copy(source, dest))
}

/// Create a new Map with default run options
pub fn new_run_options() -> Map {
    let mut map = Map::new();
    map.insert("name".into(), Dynamic::UNIT);
    map.insert("detach".into(), Dynamic::from(true));
    map.insert("ports".into(), Dynamic::from(Array::new()));
    map.insert("snapshotter".into(), Dynamic::from("native"));
    map
}

//
// Container Function Wrappers
//

/// Wrapper for nerdctl::run
///
/// Run a container from an image.
pub fn nerdctl_run(image: &str) -> Result<CommandResult, Box<EvalAltResult>> {
    nerdctl_error_to_rhai_error(nerdctl::run(image, None, true, None, None))
}

/// Run a container with a name
pub fn nerdctl_run_with_name(image: &str, name: &str) -> Result<CommandResult, Box<EvalAltResult>> {
    nerdctl_error_to_rhai_error(nerdctl::run(image, Some(name), true, None, None))
}

/// Run a container with a port mapping
pub fn nerdctl_run_with_port(
    image: &str,
    name: &str,
    port: &str,
) -> Result<CommandResult, Box<EvalAltResult>> {
    let ports = vec![port];
    nerdctl_error_to_rhai_error(nerdctl::run(image, Some(name), true, Some(&ports), None))
}

/// Wrapper for nerdctl::exec
///
/// Execute a command in a container.
pub fn nerdctl_exec(container: &str, command: &str) -> Result<CommandResult, Box<EvalAltResult>> {
    nerdctl_error_to_rhai_error(nerdctl::exec(container, command))
}

/// Wrapper for nerdctl::copy
///
/// Copy files between container and local filesystem.
pub fn nerdctl_copy(source: &str, dest: &str) -> Result<CommandResult, Box<EvalAltResult>> {
    nerdctl_error_to_rhai_error(nerdctl::copy(source, dest))
}

/// Wrapper for nerdctl::stop
///
/// Stop a container.
pub fn nerdctl_stop(container: &str) -> Result<CommandResult, Box<EvalAltResult>> {
    nerdctl_error_to_rhai_error(nerdctl::stop(container))
}

/// Wrapper for nerdctl::remove
///
/// Remove a container.
pub fn nerdctl_remove(container: &str) -> Result<CommandResult, Box<EvalAltResult>> {
    nerdctl_error_to_rhai_error(nerdctl::remove(container))
}

/// Wrapper for nerdctl::list
///
/// List containers.
pub fn nerdctl_list(all: bool) -> Result<CommandResult, Box<EvalAltResult>> {
    nerdctl_error_to_rhai_error(nerdctl::list(all))
}

/// Wrapper for nerdctl::logs
///
/// Get container logs.
pub fn nerdctl_logs(container: &str) -> Result<CommandResult, Box<EvalAltResult>> {
    nerdctl_error_to_rhai_error(nerdctl::logs(container))
}

//
// Image Function Wrappers
//

/// Wrapper for nerdctl::images
///
/// List images in local storage.
pub fn nerdctl_images() -> Result<CommandResult, Box<EvalAltResult>> {
    nerdctl_error_to_rhai_error(nerdctl::images())
}

/// Wrapper for nerdctl::image_remove
///
/// Remove one or more images.
pub fn nerdctl_image_remove(image: &str) -> Result<CommandResult, Box<EvalAltResult>> {
    nerdctl_error_to_rhai_error(nerdctl::image_remove(image))
}

/// Wrapper for nerdctl::image_push
///
/// Push an image to a registry.
pub fn nerdctl_image_push(
    image: &str,
    destination: &str,
) -> Result<CommandResult, Box<EvalAltResult>> {
    nerdctl_error_to_rhai_error(nerdctl::image_push(image, destination))
}

/// Wrapper for nerdctl::image_tag
///
/// Add an additional name to a local image.
pub fn nerdctl_image_tag(image: &str, new_name: &str) -> Result<CommandResult, Box<EvalAltResult>> {
    nerdctl_error_to_rhai_error(nerdctl::image_tag(image, new_name))
}

/// Wrapper for nerdctl::image_pull
///
/// Pull an image from a registry.
pub fn nerdctl_image_pull(image: &str) -> Result<CommandResult, Box<EvalAltResult>> {
    nerdctl_error_to_rhai_error(nerdctl::image_pull(image))
}

/// Wrapper for nerdctl::image_commit
///
/// Commit a container to an image.
pub fn nerdctl_image_commit(
    container: &str,
    image_name: &str,
) -> Result<CommandResult, Box<EvalAltResult>> {
    nerdctl_error_to_rhai_error(nerdctl::image_commit(container, image_name))
}

/// Wrapper for nerdctl::image_build
///
/// Build an image using a Dockerfile.
pub fn nerdctl_image_build(
    tag: &str,
    context_path: &str,
) -> Result<CommandResult, Box<EvalAltResult>> {
    nerdctl_error_to_rhai_error(nerdctl::image_build(tag, context_path))
}

/// Register Nerdctl module functions with the Rhai engine
///
/// # Arguments
///
/// * `engine` - The Rhai engine to register the functions with
///
/// # Returns
///
/// * `Result<(), Box<EvalAltResult>>` - Ok if registration was successful, Err otherwise
pub fn register_nerdctl_module(engine: &mut Engine) -> Result<(), Box<EvalAltResult>> {
    // Register types
    register_nerdctl_types(engine)?;

    // Register Container constructor
    engine.register_fn("nerdctl_container_new", container_new);
    engine.register_fn("nerdctl_container_from_image", container_from_image);

    // TODO: check if this works!
    // Register Container instance methods
    engine.register_fn("reset", container_reset);

    // TODO: these functions should be getters and setter like the buildah example
    // engine.register_fn("with_image", container_with_image);
    // engine.register_fn("with_port", container_with_port);
    // engine.register_fn("with_volume", container_with_volume);
    // engine.register_fn("with_env", container_with_env);
    // engine.register_fn("with_network", container_with_network);
    // engine.register_fn("with_network_alias", container_with_network_alias);
    // engine.register_fn("with_cpu_limit", container_with_cpu_limit);
    // engine.register_fn("with_memory_limit", container_with_memory_limit);
    // engine.register_fn("with_restart_policy", container_with_restart_policy);
    // engine.register_fn("with_health_check", container_with_health_check);
    // engine.register_fn("with_ports", container_with_ports);
    // engine.register_fn("with_volumes", container_with_volumes);
    // engine.register_fn("with_envs", container_with_envs);
    // engine.register_fn("with_network_aliases", container_with_network_aliases);
    // engine.register_fn("with_memory_swap_limit", container_with_memory_swap_limit);
    // engine.register_fn("with_cpu_shares", container_with_cpu_shares);
    // engine.register_fn(
    //     "with_health_check_options",
    //     container_with_health_check_options,
    // );
    // engine.register_fn("with_snapshotter", container_with_snapshotter);
    // engine.register_fn("with_detach", container_with_detach);

    engine.register_fn("build", container_build);
    engine.register_fn("start", container_start);
    engine.register_fn("stop", container_stop);
    engine.register_fn("remove", container_remove);
    engine.register_fn("exec", container_exec);
    engine.register_fn("logs", container_logs);
    engine.register_fn("copy", container_copy);

    // Register legacy container functions (for backward compatibility)
    engine.register_fn("nerdctl_run", nerdctl_run);
    engine.register_fn("nerdctl_run_with_name", nerdctl_run_with_name);
    engine.register_fn("nerdctl_run_with_port", nerdctl_run_with_port);
    engine.register_fn("new_run_options", new_run_options);
    engine.register_fn("nerdctl_exec", nerdctl_exec);
    engine.register_fn("nerdctl_copy", nerdctl_copy);
    engine.register_fn("nerdctl_stop", nerdctl_stop);
    engine.register_fn("nerdctl_remove", nerdctl_remove);
    engine.register_fn("nerdctl_list", nerdctl_list);
    engine.register_fn("nerdctl_logs", nerdctl_logs);

    // Register image functions
    engine.register_fn("nerdctl_images", nerdctl_images);
    engine.register_fn("nerdctl_image_remove", nerdctl_image_remove);
    engine.register_fn("nerdctl_image_push", nerdctl_image_push);
    engine.register_fn("nerdctl_image_tag", nerdctl_image_tag);
    engine.register_fn("nerdctl_image_pull", nerdctl_image_pull);
    engine.register_fn("nerdctl_image_commit", nerdctl_image_commit);
    engine.register_fn("nerdctl_image_build", nerdctl_image_build);

    Ok(())
}

/// Register Nerdctl module types with the Rhai engine
fn register_nerdctl_types(engine: &mut Engine) -> Result<(), Box<EvalAltResult>> {
    // Register Container type
    engine.register_type_with_name::<Container>("NerdctlContainer");
    engine.register_type_with_name::<HealthCheck>("NerdctlHealthCheck");

    // Register getters & setters for HealthCheck properties
    engine.register_get("cmd", |hc: &mut HealthCheck| hc.cmd.clone());
    engine.register_set("cmd", |hc: &mut HealthCheck, cmd: &str| {
        hc.cmd = cmd.to_string();
    });
    engine.register_get("interval", |hc: &mut HealthCheck| {
        hc.interval.clone().unwrap_or_default()
    });
    engine.register_set("interval", |hc: &mut HealthCheck, interval: &str| {
        hc.interval = Some(interval.to_string());
    });
    engine.register_get("timeout", |hc: &mut HealthCheck| {
        hc.timeout.clone().unwrap_or_default()
    });
    engine.register_set("timeout", |hc: &mut HealthCheck, timeout: &str| {
        hc.timeout = Some(timeout.to_string());
    });
    engine.register_get("retries", |hc: &mut HealthCheck| {
        hc.retries.map_or(0, |r| r as i64)
    });
    engine.register_set("retries", |hc: &mut HealthCheck, retries: i64| {
        hc.retries = Some(retries as u32);
    });
    engine.register_get("start_period", |hc: &mut HealthCheck| {
        hc.start_period.clone().unwrap_or_default()
    });
    engine.register_set("start_period", |hc: &mut HealthCheck, start_period: &str| {
        hc.start_period = Some(start_period.to_string());
    });

    // Register getters & setters for Container properties

    // -- name
    engine.register_get("name", |container: &mut Container| container.name.clone());
    engine.register_set("image", |container: &mut Container, image: &str| {
        container.image = Some(image.to_string());
    });

    // -- container_id
    engine.register_get(
        "container_id",
        |container: &mut Container| match &container.container_id {
            Some(id) => id.clone(),
            None => "".to_string(),
        },
    );
    engine.register_set("container_id", |container: &mut Container, container_id: &str| {
        container.container_id = Some(container_id.to_string());
    });

    // -- image
    engine.register_get("image", |container: &mut Container| {
        match &container.image {
            Some(img) => img.clone(),
            None => "".to_string(),
        }
    });
    engine.register_set("image", |container: &mut Container, image: &str| {
        container.image = Some(image.to_string());
    });

    // -- config
    engine.register_get("config", |container: &mut Container| {
        container
            .config
            .iter()
            .map(|(k, v)| (k.clone().into(), v.clone().into()))
            .collect::<Map>()
    });
    engine.register_set("config", |container: &mut Container, config: Map| {
        container.config = config
            .into_iter()
            .map(|(k, v)| (k.to_string(), v.into_string().unwrap_or_default()))
            .collect();
    });

    // -- ports
    engine.register_get("ports", |container: &mut Container| {
        let mut array = Array::new();
        for port in &container.ports {
            array.push(Dynamic::from(port.clone()));
        }
        array
    });
    engine.register_set("ports", |container: &mut Container, ports: Array| {
        container.ports = ports
            .into_iter()
            .map(|v| v.into_string().unwrap_or_default())
            .collect();
    });

    // -- volumes
    engine.register_get("volumes", |container: &mut Container| {
        let mut array = Array::new();
        for volume in &container.volumes {
            array.push(Dynamic::from(volume.clone()));
        }
        array
    });
    engine.register_set("volumes", |container: &mut Container, volumes: Array| {
        container.volumes = volumes
            .into_iter()
            .map(|v| v.into_string().unwrap_or_default())
            .collect();
    });

    // -- env_vars
    engine.register_get("env_vars", |container: &mut Container| {
        container
            .env_vars
            .iter()
            .map(|(k, v)| (k.clone().into(), v.clone().into()))
            .collect::<Map>()
    });
    engine.register_set("env_vars", |container: &mut Container, env_vars: Map| {
        container.env_vars = env_vars
            .into_iter()
            .map(|(k, v)| (k.to_string(), v.into_string().unwrap_or_default()))
            .collect();
    });

    // -- network
    engine.register_get("network", |container: &mut Container| {
        container.network.clone().unwrap_or_default()
    });
    engine.register_set("network", |container: &mut Container, network: &str| {
        container.network = Some(network.to_string());
    });

    // -- network_aliases
    engine.register_get("network_aliases", |container: &mut Container| {
        container
            .network_aliases
            .iter()
            .map(|alias| Dynamic::from(alias.clone()))
            .collect::<Array>()
    });
    engine.register_set(
        "network_aliases",
        |container: &mut Container, aliases: Array| {
            container.network_aliases = aliases
                .into_iter()
                .map(|a| a.into_string().unwrap_or_default())
                .collect();
        },
    );

    // -- cpu_limit
    engine.register_get("cpu_limit", |container: &mut Container| {
        container.cpu_limit.clone().unwrap_or_default()
    });
    engine.register_set("cpu_limit", |container: &mut Container, limit: &str| {
        container.cpu_limit = Some(limit.to_string());
    });

    // -- memory_limit
    engine.register_get("memory_limit", |container: &mut Container| {
        container.memory_limit.clone().unwrap_or_default()
    });
    engine.register_set("memory_limit", |container: &mut Container, limit: &str| {
        container.memory_limit = Some(limit.to_string());
    });

    // -- memory_swap_limit
    engine.register_get("memory_swap_limit", |container: &mut Container| {
        container.memory_swap_limit.clone().unwrap_or_default()
    });
    engine.register_set(
        "memory_swap_limit",
        |container: &mut Container, limit: &str| {
            container.memory_swap_limit = Some(limit.to_string());
        },
    );

    // -- cpu_shares
    engine.register_get("cpu_shares", |container: &mut Container| {
        container.cpu_shares.clone().unwrap_or_default()
    });
    engine.register_set("cpu_shares", |container: &mut Container, shares: &str| {
        container.cpu_shares = Some(shares.to_string());
    });

    // -- restart_policy
    engine.register_get("restart_policy", |container: &mut Container| {
        container.restart_policy.clone().unwrap_or_default()
    });
    engine.register_set(
        "restart_policy",
        |container: &mut Container, policy: &str| {
            container.restart_policy = Some(policy.to_string());
        },
    );

    // TODO: setters and getters for health_check
    // -- health_check
    // engine.register_get("health_check", |container: &mut Container| {
    //     container.health_check.clone()
    // });
    // engine.register_set(
    //     "health_check",
    //     |container: &mut Container, health_check: HealthCheck| {
    //         container.health_check = Some(health_check);
    //     },
    // );

    // -- detach
    engine.register_get("detach", |container: &mut Container| container.detach);
    engine.register_set("detach", |container: &mut Container, detach: bool| {
        container.detach = detach;
    });

    // -- snapshotter
    engine.register_get("snapshotter", |container: &mut Container| {
        container.snapshotter.clone().unwrap_or_default()
    });
    engine.register_set("snapshotter", |container: &mut Container, snapshotter: &str| {
        container.snapshotter = Some(snapshotter.to_string());
    });

    // Register Image type and methods
    engine.register_type_with_name::<Image>("NerdctlImage");

    // Register getters for Image properties
    engine.register_get("id", |img: &mut Image| img.id.clone());
    engine.register_get("repository", |img: &mut Image| img.repository.clone());
    engine.register_get("tag", |img: &mut Image| img.tag.clone());
    engine.register_get("size", |img: &mut Image| img.size.clone());
    engine.register_get("created", |img: &mut Image| img.created.clone());

    Ok(())
}