/*
 * Copyright (c) 2025 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <iostream>

#include "restool_errors.h"

namespace OHOS {
namespace Global {
namespace Restool {
const std::map<uint32_t, ErrorInfo> ERRORS_MAP = {
    // 11201xxx
    { ERR_CODE_LOAD_LIBRARY_FAIL,
      { ERR_CODE_LOAD_LIBRARY_FAIL,
        ERR_TYPE_DEPENDENCY,
        "Load library failed, path: '%s', %s",
        "",
        { "Make sure the library path is correct and has access permissions." },
        {} } },

    // 11203xxx
    { ERR_CODE_OPEN_JSON_FAIL,
      { ERR_CODE_OPEN_JSON_FAIL,
        ERR_TYPE_CONFIG,
        "Open json file '%s' failed, %s.",
        "",
        { "Make sure the json file path is correct and has access permissions." },
        {} } },
    { ERR_CODE_JSON_FORMAT_ERROR,
      { ERR_CODE_JSON_FORMAT_ERROR,
        ERR_TYPE_CONFIG,
        "Parse json file failed, please check the file.",
        "",
        { "Check the JSON file and delete unnecessary commas (,).",
          "Check the JSON file to make sure the root bracket is {}." },
        {} } },
    { ERR_CODE_JSON_NODE_MISMATCH,
      { ERR_CODE_JSON_NODE_MISMATCH,
        ERR_TYPE_CONFIG,
        "Parse json file failed, the '%s' node type mismatch, expected type: '%s'.",
        "",
        {},
        {} } },
    { ERR_CODE_JSON_NODE_MISSING,
      { ERR_CODE_JSON_NODE_MISSING, ERR_TYPE_CONFIG, "The required node '%s' is missing.", "", {}, {} } },
    { ERR_CODE_JSON_NODE_EMPTY,
      { ERR_CODE_JSON_NODE_EMPTY, ERR_TYPE_CONFIG, "The array or object node '%s' cannot be empty.", "", {}, {} } },
    { ERR_CODE_JSON_NOT_ONE_MEMBER,
      { ERR_CODE_JSON_NOT_ONE_MEMBER,
        ERR_TYPE_CONFIG,
        "The node '%s' of the json file can only have one member.",
        "",
        {},
        {} } },
    { ERR_CODE_JSON_INVALID_NODE_NAME,
      { ERR_CODE_JSON_INVALID_NODE_NAME, ERR_TYPE_CONFIG, "Invalid node name '%s'.", "", {}, {} } },

    // 11204xxx
    { ERR_CODE_CREATE_FILE_ERROR,
      { ERR_CODE_CREATE_FILE_ERROR,
        ERR_TYPE_FILE_RESOURCE,
        "Create directory or file '%s' failed, %s.",
        "",
        { "Make sure the file path is correct and has access permissions." },
        {} } },
    { ERR_CODE_FILE_NOT_EXIST,
      { ERR_CODE_FILE_NOT_EXIST,
        ERR_TYPE_FILE_RESOURCE,
        "File not exists, '%s'.",
        "",
        { "Make sure the file path is correct." },
        {} } },
    { ERR_CODE_REMOVE_FILE_ERROR,
      { ERR_CODE_REMOVE_FILE_ERROR,
        ERR_TYPE_FILE_RESOURCE,
        "Remove dir/file '%s' failed, %s.",
        "",
        { "Make sure the file path is correct." },
        {} } },
    { ERR_CODE_COPY_FILE_ERROR,
      { ERR_CODE_COPY_FILE_ERROR,
        ERR_TYPE_FILE_RESOURCE,
        "Copy file from '%s' to '%s' failed, %s.",
        "",
        { "Make sure the src and dest file path is correct and has access permissions." },
        {} } },
    { ERR_CODE_OPEN_FILE_ERROR,
      { ERR_CODE_OPEN_FILE_ERROR,
        ERR_TYPE_FILE_RESOURCE,
        "Open file failed '%s', %s.",
        "",
        { "Make sure the src and dest file path is correct and has access permissions." },
        {} } },
    { ERR_CODE_FILE_EMPTY, { ERR_CODE_FILE_EMPTY, ERR_TYPE_FILE_RESOURCE, "File is empty '%s'.", "", {}, {} } },
    { ERR_CODE_FILE_STREAM_ERROR,
      { ERR_CODE_FILE_STREAM_ERROR, ERR_TYPE_FILE_RESOURCE, "File stream bad, state code: %d.", "", {}, {} } },
    { ERR_CODE_FILE_MAP_ERROR,
      { ERR_CODE_FILE_MAP_ERROR, ERR_TYPE_FILE_RESOURCE, "File mapping failed, %s.", "", {}, {} } },

    // 11205xxx
    { ERR_CODE_SET_DATA_ERROR,
      { ERR_CODE_SET_DATA_ERROR,
        ERR_TYPE_SYNTAX,
        "Set resource item data of '%s' failed, it may be due to insufficient memory.",
        "",
        { "Retry compile." },
        {} } },
    { ERR_CODE_ITEM_DATA_NULL,
      { ERR_CODE_ITEM_DATA_NULL,
        ERR_TYPE_SYNTAX,
        "Get resource item data of '%s' failed, null.",
        "",
        { "Retry compile." },
        {} } },
    { ERR_CODE_MEMCPY_ERROR,
      { ERR_CODE_MEMCPY_ERROR, ERR_TYPE_SYNTAX, "Memory copy failed in '%s'.", "", { "Retry compile." }, {} } },
    { ERR_CODE_CREATE_JSON_ERROR,
      { ERR_CODE_CREATE_JSON_ERROR,
        ERR_TYPE_SYNTAX,
        "Generate JSON failed, %s.",
        "",
        { "Run the command again." },
        {} } },

    // 11210xxx
    { ERR_CODE_UNKNOWN_COMMAND_ERROR,
      { ERR_CODE_UNKNOWN_COMMAND_ERROR,
        ERR_TYPE_COMMAND_PARSE,
        "Unknown error: %s",
        "",
        { "For details, see the help with option -h/--help." },
        {} } },
    { ERR_CODE_UNKNOWN_OPTION,
      { ERR_CODE_UNKNOWN_OPTION,
        ERR_TYPE_COMMAND_PARSE,
        "Unknown option: '%s'",
        "",
        { "For details, see the help with option -h/--help." },
        {} } },
    { ERR_CODE_MISSING_ARGUMENT,
      { ERR_CODE_MISSING_ARGUMENT,
        ERR_TYPE_COMMAND_PARSE,
        "Option '%s' must have argument",
        "",
        { "For details, see the help with option -h/--help." },
        {} } },
    { ERR_CODE_INVALID_ARGUMENT,
      { ERR_CODE_INVALID_ARGUMENT,
        ERR_TYPE_COMMAND_PARSE,
        "Invalid arguments : '%s'",
        "",
        { "For details, see the help with option -h/--help." },
        {} } },
    { ERR_CODE_INVALID_INPUT,
      { ERR_CODE_INVALID_INPUT,
        ERR_TYPE_COMMAND_PARSE,
        "Invalid input '%s'",
        "",
        { "Make sure the input path of option -i/--inputPath is correct." },
        {} } },
    { ERR_CODE_DUPLICATE_INPUT,
      { ERR_CODE_DUPLICATE_INPUT,
        ERR_TYPE_COMMAND_PARSE,
        "Duplicated input '%s'",
        "",
        { "Make sure the input path of option -i/--inputPath is unique." },
        {} } },
    { ERR_CODE_DOUBLE_PACKAGE_NAME,
      { ERR_CODE_DOUBLE_PACKAGE_NAME,
        ERR_TYPE_COMMAND_PARSE,
        "Double package name '%s' vs '%s'",
        "",
        { "Make sure the option -p/--packageName only specified once." },
        {} } },
    { ERR_CODE_INVALID_OUTPUT,
      { ERR_CODE_INVALID_OUTPUT,
        ERR_TYPE_COMMAND_PARSE,
        "Invalid output '%s'",
        "",
        { "Make sure the output path of option -o/--outputPath is correct." },
        {} } },
    { ERR_CODE_DOUBLE_OUTPUT,
      { ERR_CODE_DOUBLE_OUTPUT,
        ERR_TYPE_COMMAND_PARSE,
        "Double output '%s' vs '%s'",
        "",
        { "Make sure the option -o/--outputPath only specified once." },
        {} } },
    { ERR_CODE_DUPLICATE_RES_HEADER,
      { ERR_CODE_DUPLICATE_RES_HEADER,
        ERR_TYPE_COMMAND_PARSE,
        "Duplicated res header path '%s'",
        "",
        { "Make sure the path of option -r/--resHeader is unique." },
        {} } },
    { ERR_CODE_DOUBLE_MODULES,
      { ERR_CODE_DOUBLE_MODULES,
        ERR_TYPE_COMMAND_PARSE,
        "Double module name '%s'",
        "",
        { "Make sure the option -m/--modules only specified once." },
        {} } },
    { ERR_CODE_DUPLICATE_MODULE_NAME,
      { ERR_CODE_DUPLICATE_MODULE_NAME,
        ERR_TYPE_COMMAND_PARSE,
        "Duplicated module name '%s'",
        "",
        { "Make sure the module name is unique." },
        {} } },
    { ERR_CODE_DOUBLE_CONFIG_JSON,
      { ERR_CODE_DOUBLE_CONFIG_JSON,
        ERR_TYPE_COMMAND_PARSE,
        "Double config json '%s' vs '%s'",
        "",
        { "Make sure the option -j/--json only specified once." },
        {} } },
    { ERR_CODE_INVALID_START_ID,
      { ERR_CODE_INVALID_START_ID,
        ERR_TYPE_COMMAND_PARSE,
        "Invalid start id '%s'",
        "",
        { "Make sure the start id in the scope [0x01000000, 0x06FFFFFF) or [0x08000000, 0xFFFFFFFF)" },
        {} } },
    { ERR_CODE_DUPLICATE_APPEND_PATH,
      { ERR_CODE_DUPLICATE_APPEND_PATH,
        ERR_TYPE_COMMAND_PARSE,
        "Duplicated input append path '%s'",
        "",
        { "Make sure the path of option -x/--append is unique." },
        {} } },
    { ERR_CODE_DOUBLE_TARGET_CONFIG,
      { ERR_CODE_DOUBLE_TARGET_CONFIG,
        ERR_TYPE_COMMAND_PARSE,
        "Double option '--target-config'",
        "",
        { "Make sure the option --target-config only specified once." },
        {} } },
    { ERR_CODE_INVALID_TARGET_CONFIG,
      { ERR_CODE_INVALID_TARGET_CONFIG,
        ERR_TYPE_COMMAND_PARSE,
        "Invalid target config argument '%s'",
        "",
        { "The argument format of option --target-config is supposed to be like 'Locale[zh_CN,en_US];Device[phone]', "
          "for details, see the developer documentation." },
        {} } },
    { ERR_CODE_INVALID_SYSTEM_ID_DEFINED,
      { ERR_CODE_INVALID_SYSTEM_ID_DEFINED,
        ERR_TYPE_COMMAND_PARSE,
        "Invalid system id_defined.json path '%s'",
        "",
        { "Make sure the system id_defined.json path is correct." },
        {} } },
    { ERR_CODE_DUPLICATE_SYSTEM_ID_DEFINED,
      { ERR_CODE_DUPLICATE_SYSTEM_ID_DEFINED,
        ERR_TYPE_COMMAND_PARSE,
        "Duplicated system id_defined.json path '%s'",
        "",
        { "Make sure the system id_defined.json path is unique." },
        {} } },
    { ERR_CODE_DOUBLE_COMPRESSION_PATH,
      { ERR_CODE_DOUBLE_COMPRESSION_PATH,
        ERR_TYPE_COMMAND_PARSE,
        "Double compression json path '%s' vs '%s'",
        "",
        { "Make sure the option --compressed-config only specified once." },
        {} } },
    { ERR_CODE_NON_ASCII,
      { ERR_CODE_NON_ASCII,
        ERR_TYPE_COMMAND_PARSE,
        "'%s' must be ASCII",
        "",
        { "Make sure all the argument's characters is ASCII." },
        {} } },
    { ERR_CODE_EXCLUSIVE_OPTION,
      { ERR_CODE_EXCLUSIVE_OPTION, ERR_TYPE_COMMAND_PARSE, "Option %s and %s cannot be used together.", "", {}, {} } },
    { ERR_CODE_PACKAGE_NAME_EMPTY,
      { ERR_CODE_PACKAGE_NAME_EMPTY,
        ERR_TYPE_COMMAND_PARSE,
        "Package name empty.",
        "",
        { "Specifies the package name with option -p/--packageName." },
        {} } },
    { ERR_CODE_RES_HEADER_PATH_EMPTY,
      { ERR_CODE_RES_HEADER_PATH_EMPTY,
        ERR_TYPE_COMMAND_PARSE,
        "Resource header path empty.",
        "",
        { "Specifies header path with option -r/--resHeader." },
        {} } },
    { ERR_CODE_DUMP_MISSING_INPUT,
      { ERR_CODE_DUMP_MISSING_INPUT,
        ERR_TYPE_COMMAND_PARSE,
        "Resource dump missing input path.",
        "",
        { "Specifies input path after dump command." },
        {} } },
    { ERR_CODE_DUMP_INVALID_INPUT,
      { ERR_CODE_DUMP_INVALID_INPUT,
        ERR_TYPE_COMMAND_PARSE,
        "Resource dump invalid input path.",
        "",
        { "Make sure the input path after dump command is correct." },
        {} } },
    { ERR_CODE_INVALID_THREAD_COUNT,
      { ERR_CODE_INVALID_THREAD_COUNT, ERR_TYPE_COMMAND_PARSE, "Invalid thread count: %s.", "", {}, {} } },

    // 11211xxx
    { ERR_CODE_OUTPUT_EXIST,
      { ERR_CODE_OUTPUT_EXIST,
        ERR_TYPE_RESOURCE_PACK,
        "Output path exists, but option -f/--forceWrite not specified.",
        "",
        { "Remove the exist output dir or use option -f to force write." },
        {} } },
    { ERR_CODE_CONFIG_JSON_MISSING,
      { ERR_CODE_CONFIG_JSON_MISSING,
        ERR_TYPE_RESOURCE_PACK,
        "More input path, but -j config.json not specified.",
        "",
        { "Specifies the config.json with option -j/--json." },
        {} } },
    { ERR_CODE_INVALID_MODULE_TYPE,
      { ERR_CODE_INVALID_MODULE_TYPE,
        ERR_TYPE_RESOURCE_PACK,
        "Invalid module type '%s', expected type is one of [entry, har, shared, feature].",
        "",
        {},
        {} } },
    { ERR_CODE_EXCLUSIVE_START_ID,
      { ERR_CODE_EXCLUSIVE_START_ID,
        ERR_TYPE_RESOURCE_PACK,
        "The set start_id and id_defined.json cannot be used together.",
        "",
        {},
        {} } },
    { ERR_CODE_ID_DEFINED_NODE_MISSING,
      { ERR_CODE_ID_DEFINED_NODE_MISSING,
        ERR_TYPE_RESOURCE_PACK,
        "The id_defined.json seq = %lu %s empty.",
        "",
        {},
        {} } },
    { ERR_CODE_ID_DEFINED_NODE_MISMATCH,
      { ERR_CODE_ID_DEFINED_NODE_MISMATCH,
        ERR_TYPE_RESOURCE_PACK,
        "The id_defined.json seq = %lu %s not %s.",
        "",
        {},
        {} } },
    { ERR_CODE_ID_DEFINED_INVALID_TYPE,
      { ERR_CODE_ID_DEFINED_INVALID_TYPE,
        ERR_TYPE_RESOURCE_PACK,
        "The id_defined.json seq = %lu type '%s' invalid.",
        "",
        {},
        {} } },
    { ERR_CODE_ID_DEFINED_INVALID_ID,
      { ERR_CODE_ID_DEFINED_INVALID_ID,
        ERR_TYPE_RESOURCE_PACK,
        "The id_defined.json seq = %lu id must be a hex string, eg:^0[xX][0-9a-fA-F]{8}.",
        "",
        {},
        {} } },
    { ERR_CODE_ID_DEFINED_ID_OUT_RANGE,
      { ERR_CODE_ID_DEFINED_ID_OUT_RANGE,
        ERR_TYPE_RESOURCE_PACK,
        "The id_defined.json seq = %lu id must in [0x01000000,0x06FFFFFF],[0x08000000,0xFFFFFFFF].",
        "",
        {},
        {} } },
    { ERR_CODE_ID_DEFINED_ORDER_MISMATCH,
      { ERR_CODE_ID_DEFINED_ORDER_MISMATCH,
        ERR_TYPE_RESOURCE_PACK,
        "The id_defined.json seq = %lu order value %lu vs expect %lu.",
        "",
        {},
        {} } },
    { ERR_CODE_ID_DEFINED_INVALID_START_ID,
      { ERR_CODE_ID_DEFINED_INVALID_START_ID,
        ERR_TYPE_RESOURCE_PACK,
        "The id_defined.json 'startId' is invalid.",
        "",
        {},
        {} } },
    { ERR_CODE_ID_DEFINED_SAME_ID,
      { ERR_CODE_ID_DEFINED_SAME_ID,
        ERR_TYPE_RESOURCE_PACK,
        "The id_defined.json '%s' and '%s' defind the same ID.",
        "",
        {},
        {} } },
    { ERR_CODE_ID_DEFINED_SAME_RESOURCE,
      { ERR_CODE_ID_DEFINED_SAME_RESOURCE,
        ERR_TYPE_RESOURCE_PACK,
        "The same resource of '%s' exists in the %s",
        "",
        {},
        {} } },
    { ERR_CODE_MODULE_NAME_NOT_FOUND,
      { ERR_CODE_MODULE_NAME_NOT_FOUND,
        ERR_TYPE_RESOURCE_PACK,
        "The module name '%s' in config.json not found in [%s] which specifies with -m/--modules.",
        "",
        { "Make sure the module name in config.json is correct." },
        {} } },
    { ERR_CODE_RESOURCE_PATH_NOT_DIR,
      { ERR_CODE_RESOURCE_PATH_NOT_DIR,
        ERR_TYPE_RESOURCE_PACK,
        "Scan resource failed, the path '%s' is not directory.",
        "",
        {},
        {} } },
    { ERR_CODE_INVALID_FILE_PATH,
      { ERR_CODE_INVALID_FILE_PATH,
        ERR_TYPE_RESOURCE_PACK,
        "Invalid file path '%s'.",
        "",
        { "Make sure the path is correct." },
        {} } },
    { ERR_CODE_INVALID_LIMIT_KEY,
      { ERR_CODE_INVALID_LIMIT_KEY, ERR_TYPE_RESOURCE_PACK, "Invalid limit key '%s'.", "", {}, {} } },
    { ERR_CODE_INVALID_RESOURCE_DIR,
      { ERR_CODE_INVALID_RESOURCE_DIR,
        ERR_TYPE_RESOURCE_PACK,
        "Invalid resource directory name '%s', must in [%s].",
        "",
        {},
        {} } },
    { ERR_CODE_RESOURCE_PATH_NOT_FILE,
      { ERR_CODE_RESOURCE_PATH_NOT_FILE,
        ERR_TYPE_RESOURCE_PACK,
        "Scan resource failed, the resource '%s' must be a file.",
        "",
        {},
        {} } },
    { ERR_CODE_INVALID_TRANSLATE_PRIORITY,
      { ERR_CODE_INVALID_TRANSLATE_PRIORITY,
        ERR_TYPE_RESOURCE_PACK,
        "Invalid translate priority value '%s', must in [%s].",
        "",
        {},
        {} } },
    { ERR_CODE_INVALID_ELEMENT_TYPE,
      { ERR_CODE_INVALID_ELEMENT_TYPE, ERR_TYPE_RESOURCE_PACK, "Unsupport element resource type '%s'.", "", {}, {} } },
    { ERR_CODE_INVALID_COLOR_VALUE,
      { ERR_CODE_INVALID_COLOR_VALUE,
        ERR_TYPE_RESOURCE_PACK,
        "Invalid color value '%s', only support refer '$color:xxx' or '#rgb','#argb','#rrggbb','#aarrggbb'.",
        "",
        {},
        {} } },
    { ERR_CODE_INVALID_RESOURCE_REF,
      { ERR_CODE_INVALID_RESOURCE_REF,
        ERR_TYPE_RESOURCE_PACK,
        "Invalid resource reference '%s', only support refer '%sxxx'.",
        "",
        {},
        {} } },
    { ERR_CODE_PARENT_EMPTY,
      { ERR_CODE_PARENT_EMPTY,
        ERR_TYPE_RESOURCE_PACK,
        "The resource's parent is emptry, type: '%s', name: '%s'.",
        "",
        {},
        {} } },
    { ERR_CODE_ARRAY_TOO_LARGE,
      { ERR_CODE_ARRAY_TOO_LARGE, ERR_TYPE_RESOURCE_PACK, "The array resource '%s' is to large.", "", {}, {} } },
    { ERR_CODE_INVALID_QUANTITY,
      { ERR_CODE_INVALID_QUANTITY,
        ERR_TYPE_RESOURCE_PACK,
        "Invalid quantity resource, name: '%s', quantity: '%s', the quantity must be one of [%s].",
        "",
        {},
        {} } },
    { ERR_CODE_DUPLICATE_QUANTITY,
      { ERR_CODE_DUPLICATE_QUANTITY,
        ERR_TYPE_RESOURCE_PACK,
        "Duplicated quantity resource, name: '%s', quantity: '%s'.",
        "",
        {},
        {} } },
    { ERR_CODE_QUANTITY_NO_OTHER,
      { ERR_CODE_QUANTITY_NO_OTHER,
        ERR_TYPE_RESOURCE_PACK,
        "The quantity resource '%s' must contains 'other' quantity.",
        "",
        {},
        {} } },
    { ERR_CODE_INVALID_SYMBOL,
      { ERR_CODE_INVALID_SYMBOL,
        ERR_TYPE_RESOURCE_PACK,
        "The symbol resource '%s' invalid, value must in 0xF0000 ~ 0xFFFFF or 0x100000 ~ 0x10FFFF.",
        "",
        {},
        {} } },
    { ERR_CODE_INVALID_RESOURCE_NAME,
      { ERR_CODE_INVALID_RESOURCE_NAME,
        ERR_TYPE_RESOURCE_PACK,
        "Invalid resource name '%s', the name can only contain [a-zA-Z0-9_].",
        "",
        { "Modify the name to match [a-zA-Z0-9_]." },
        {} } },
    { ERR_CODE_RESOURCE_DUPLICATE,
      { ERR_CODE_RESOURCE_DUPLICATE,
        ERR_TYPE_RESOURCE_PACK,
        "Resource '%s' conflict, first declared at %s, but declare again at %s.",
        "",
        { "Make sure the resource names of same type are unique." },
        {} } },
    { ERR_CODE_RESOURCE_ID_EXCEED,
      { ERR_CODE_RESOURCE_ID_EXCEED,
        ERR_TYPE_RESOURCE_PACK,
        "The resource id %lu exceed, greater than the max id %lu",
        "",
        {},
        {} } },
    { ERR_CODE_RESOURCE_ID_NOT_DEFINED,
      { ERR_CODE_RESOURCE_ID_NOT_DEFINED,
        ERR_TYPE_RESOURCE_PACK,
        "The resource id not be defined, resource type: %s, name: '%s'.",
        "",
        {},
        {} } },
    { ERR_CODE_REF_NOT_DEFINED,
      { ERR_CODE_REF_NOT_DEFINED,
        ERR_TYPE_RESOURCE_PACK,
        "The resource reference '%s' don't be defined.",
        "",
        {},
        {} } },
    { ERR_CODE_ARRAY_DECOMPOSE_ERROR,
      { ERR_CODE_ARRAY_DECOMPOSE_ERROR,
        ERR_TYPE_RESOURCE_PACK,
        "Decompose strings failed, name: '%s', data: '%s'.",
        "",
        {},
        {} } },
    { ERR_CODE_ARRAY_COMPOSE_ERROR,
      { ERR_CODE_ARRAY_COMPOSE_ERROR,
        ERR_TYPE_RESOURCE_PACK,
        "Compose strings failed, name: '%s', content size: '%lu'.",
        "",
        {},
        {} } },
    { ERR_CODE_FA_ENTRY_NO_ICON_LABEL,
      { ERR_CODE_FA_ENTRY_NO_ICON_LABEL,
        ERR_TYPE_RESOURCE_PACK,
        "Entry MainAbility must have 'icon' and 'label'.",
        "",
        {},
        {} } },
    { ERR_CODE_INVALID_RESOURCE_INDEX,
      { ERR_CODE_INVALID_RESOURCE_INDEX, ERR_TYPE_RESOURCE_PACK, "Invalid resources.index %s.", "", {}, {} } },
    { ERR_CODE_RESOURCE_INDEX_ID_NOT_FOUND,
      { ERR_CODE_RESOURCE_INDEX_ID_NOT_FOUND,
        ERR_TYPE_RESOURCE_PACK,
        "Find resource items in resources.index failed, the id %lu not found.",
        "",
        {},
        {} } },
    { ERR_CODE_RESOURCE_INDEX_ITEM_EMPTY,
      { ERR_CODE_RESOURCE_INDEX_ITEM_EMPTY,
        ERR_TYPE_RESOURCE_PACK,
        "Find resource items in resources.index failed, the items of id %lu is empty.",
        "",
        {},
        {} } },
    { ERR_CODE_RESOURCE_INDEX_INVALID_RESTYPE,
      { ERR_CODE_RESOURCE_INDEX_INVALID_RESTYPE,
        ERR_TYPE_RESOURCE_PACK,
        "Find resource items in resources.index failed, invalid restype '%s', expected type '%s'.",
        "",
        {},
        {} } },
    { ERR_CODE_SAVE_INDEX_ERROR,
      { ERR_CODE_SAVE_INDEX_ERROR,
        ERR_TYPE_RESOURCE_PACK,
        "Save resources to resources.index failed, %s.",
        "",
        {},
        {} } },
    { ERR_CODE_CREATE_ID_DEFINED_ERROR,
      { ERR_CODE_CREATE_ID_DEFINED_ERROR,
        ERR_TYPE_RESOURCE_PACK,
        "Create id defined json '%s' failed, %s.",
        "",
        {},
        {} } },

    // 11212xxx
    { ERR_CODE_PARSE_HAP_ERROR,
      { ERR_CODE_PARSE_HAP_ERROR, ERR_TYPE_RESOURCE_PACK, "Parse hap failed, %s.", "", {}, {} } },
};

ErrorInfo GetError(const uint32_t &errCode)
{
    ErrorInfo error;
    if (ERRORS_MAP.count(errCode) == 0) {
        return error;
    }
    auto it = ERRORS_MAP.find(errCode);
    if (it != ERRORS_MAP.end()) {
        return it->second;
    }
    return error;
}

void PrintError(const uint32_t &errCode)
{
    PrintError(GetError(errCode));
}

void PrintError(const ErrorInfo &error)
{
    std::string errMsg;
    errMsg.append("Error Code: ").append(std::to_string(error.code_)).append("\n");
    errMsg.append("Error: ").append(error.description_).append("\n");
    errMsg.append("Error Message: ").append(error.cause_);
    if (!error.position_.empty()) {
        errMsg.append(" At ").append(error.position_);
    }
    errMsg.append("\n");
    if (!error.solutions_.empty()) {
        errMsg.append("* Try the following:").append("\n");
        for (const auto &solution : error.solutions_) { errMsg.append("  > ").append(solution).append("\n"); }
        if (!error.moreInfo_.cn.empty()) {
            errMsg.append("> More info: ").append(error.moreInfo_.cn).append("\n");
        }
    }
    std::cerr << errMsg;
}
} // namespace Restool
} // namespace Global
} // namespace OHOS