use serde_json;
use std::fs::File;
use std::io;
use std::path::PathBuf;

error_chain! {
    types { }

    links { }

    foreign_links {
        io::Error, IoError;
        serde_json::Error, SerdeJsonError;
    }

    errors {
        AbsolutePathNotFound(path: PathBuf) {
            description("Error locating absolute path. The path does not exist.")
            display(
                "{}{}{}",
                "Error locating absolute path. The path, '",
                path.to_string_lossy(),
                "', does not exist.",
            )
        }

        DependencyHasNoName(path: PathBuf) {
            description("Error loading dependency. The dependency has no name.")
            display(
                "{}{}{}",
                "Error loading dependency at path, '",
                path.to_string_lossy(),
                "'. The dependnecy has no name.",
            )
        }

        DependencyHasNoVersion(name: String, path: PathBuf) {
            description("Error loading dependency. The dependency has no version.")
            display(
                "{}{}{}{}{}",
                "Error loading dependency, '",
                name,
                "' at path, '",
                path.to_string_lossy(),
                "'. The dependnecy has no version.",
            )
        }

        FileFromPathFailure(path: PathBuf) {
            description("Error opening file. The file could not be opened.")
            display(
                "{}{}{}",
                "Error opending file at path, '",
                path.to_string_lossy(),
                "'. The file could not be opended.",
            )
        }

        FileNotFoundInPlugin(file: PathBuf, full_path: PathBuf) {
            description("Error locating file in plugin. The file does not exist.")
            display(
                "{}{}{}{}{}",
                "Error locating file in plugin. The file, '",
                file.to_string_lossy(),
                "', does not exist at '",
                full_path.to_string_lossy(),
                "'.",
            )
        }

        NotImplemented(description: String, display: String) {
            description(description)
            display(
                "{}",
                display,
            )
        }

        ModuleFolderNotFound(module_id: usize) {
            description("The module folder could not be found.")
            display(
                "{}{}{}",
                "The module folder with id, '",
                module_id,
                "could not be found.",
            )
        }

        PathVerificationNotAbsolute(path: PathBuf) {
            description("Error verifying path. To path is not absolute.")
            display(
                "{}{}{}",
                "Error verifying path. The path, '",
                path.to_string_lossy(),
                "', is not absolute.",
            )
        }

        PathVerificationNotDirectory(path: PathBuf) {
            description("Error verifying path. To path is not a directory.")
            display(
                "{}{}{}",
                "Error verifying path. The path, '",
                path.to_string_lossy(),
                "', is not a directory.",
            )
        }

        PathVerificationNotExist(path: PathBuf) {
            description("Error verifying path. To path is does not exist.")
            display(
                "{}{}{}",
                "Error verifying path. The path, '",
                path.to_string_lossy(),
                "', does not exist.",
            )
        }

        PathVerificationNotFile(path: PathBuf) {
            description("Error verifying path. To path is not a file.")
            display(
                "{}{}{}",
                "Error verifying path. The path, '",
                path.to_string_lossy(),
                "', is not a file.",
            )
        }

        PluginDeserializationFailure(plugin_text: String) {
            description("Error deserializing plugin text. The plugin text could not be deserialized.")
            display(
                "{}{}{}",
                "Error deserializing plugin text:\n",
                plugin_text,
                "\nThe plugin text could not be deserialized.",
            )
        }

        PluginLoadNameCollision(name: String) {
            description("Error loading plugin. A plugin with the specified name has already been loaded.")
            display(
                "{}{}{}",
                "Error loading plugin with name, '",
                name,
                "'. A plugin with the specified name has already been loaded.",
            )
        }

        PluginLoadPathCollision(path: PathBuf) {
            description("Error loading plugin. A plugin at the specified path has already been loaded.")
            display(
                "{}{}{}",
                "Error loading plugin at path, '",
                path.to_string_lossy(),
                "'. A plugin at the specified path has already been loaded.",
            )
        }

        PluginNotFoundInPluginMap(plugin_name: String) {
            description("Error locating plugin in plugin map. The plugin could not be found.")
            display(
                "{}{}{}",
                "Error locating plugin with name, '",
                plugin_name,
                "', in plugin map. The plugin could not be found.",
            )
        }

        PluginPathIdIncorrect(path: PathBuf, plugin_id: usize, next_id: usize) {
            description("Error adding plugin path. A plugin with the current id cannot be added.")
            display(
                "{}{}{}{}{}{}{}",
                "Error adding plugin path, '",
                path.to_string_lossy(),
                "'. A plugin with path with the id, '",
                plugin_id,
                "', cannot be added. The next plugin id should be, '",
                next_id,
                "'.",
            )
        }

        PluginPathNotFound(file: PathBuf, plugin_id: usize) {
            description("Error finding plugin path for file. A plugin the requested id does not exist.")
            display(
                "{}{}{}{}{}",
                "Error finding plugin path for file, '",
                file.to_string_lossy(),
                "'. A plugin with the requested id, '",
                plugin_id,
                "', does not exist.",
            )
        }

        RelativePathNotFound(path: PathBuf, search_paths: Vec<PathBuf>) {
            description("Error locating relative path. The path does not exist.")
            display(
                "{}{}{}{}",
                "Error locating relative path, '",
                path.to_string_lossy(),
                "', the path could not be found. The following paths were searched:",
                {
                    let mut result = String::new();
                    for search_path in search_paths {
                        let this_result =
                            format!(
                                "{}{}{}",
                                "\n'",
                                search_path.to_string_lossy(),
                                "'",
                            );
                        result.push_str(&this_result);
                    }
                    result
                },
            )
        }

        SubmoduleNotExist(module_id: usize, submodule_id: usize) {
            description("The submodule does not exist.")
            display(
                "{}{}{}{}{}",
                "Error locating with id, '",
                submodule_id,
                "', while searching in module with id, '",
                module_id,
                "'. The submodule does not exist.",
            )
        }

        SubmodulePathNoModule(module_id: usize, submodule_id: usize, path: PathBuf) {
            description("Error locating submodule path. The module id containing the submodule is invalid.")
            display(
                "{}{}{}{}{}{}{}",
                "Error locating submodule path. The module id, ",
                module_id,
                ", containing the submodule with id, ",
                submodule_id,
                ", cannot be found. The search path is, '",
                path.to_string_lossy(),
                "'.",
            )
        }

        SubmodulePathNoSubmodule(module_path: PathBuf, submodule_id: usize, path: PathBuf) {
            description("Error locating submodule path. The submodule id is invalid.")
            display(
                "{}{}{}",
                "Error locating submodule path. The submodule id, ",
                submodule_id,
                ", cannot be found.",
            )
        }

        SubmodulePathNotExist(module_id: usize, submodule: String, path: PathBuf) {
            description("Error locating submodule path. The submodule path does not exist.")
            display(
                "{}{}{}",
                "Error locating submodule path. The submodule path, ",
                path.to_string_lossy(),
                ", does not exist.",
            )
        }

        TextFromFileFailure(file: File) {
            description("Error reading text from file. The file could not be read.")
            display(
                "{}{:?}{}",
                "Error reading text from file:\n",
                file,
                "\nThe file could not be read. Cause:\n",
            )
        }
    }
}