#!/usr/bin/env python3
# -*- coding: UTF-8 -*-
# -----------------------------------------------------------------------------------------------------------
# Copyright (c) 2025 Huawei Technologies Co., Ltd.
# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
# CANN Open Software License Agreement Version 2.0 (the "License").
# Please refer to the License for details. You may not use this file except in compliance with the License.
# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
# INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
# See LICENSE in the root of the software repository for the full text of the License.
# -----------------------------------------------------------------------------------------------------------

import argparse
import csv
import os
import shutil
import sys
import traceback
from argparse import Namespace
from collections import namedtuple
from collections.abc import Iterator
from datetime import datetime, timezone
from functools import partial
from itertools import chain
from typing import TextIO

import regex as re
from common.py.filelist import (
    FileItem,
    FileList,
    check_filelist,
    create_file_item,
    generate_filelist,
    get_transform_nested_path_func,
)
from common.py.packer import PackageName, create_makeself_pkg_params_factory, create_run_package_command, exec_pack_cmd
from common.py.pkg_parser import ParseOption, XmlConfig, get_cann_version_info, parse_xml_config
from common.py.utils import pkg_utils
from common.py.utils.comm_log import CommLog
from common.py.utils.funcbase import invoke, pipe
from common.py.utils.pkg_utils import (
    CONFIG_SCRIPT_PATH,
    DELIVERY_PATH,
    FAIL,
    SUCCESS,
    TOP_DIR,
    CompressError,
    ContainAsteriskError,
    FilelistError,
    GenerateFilelistError,
    PackageNameEmptyError,
    UnknownOperateTypeError,
    path_join,
)


def get_comments(package_name: PackageName) -> str:
    """获取run包注释。"""
    comments = "_".join([package_name.chip_name.upper(), package_name.func_name.upper(), "RUN_PACKAGE"])
    return f'"{comments}"'


def get_compress_cmd(delivery_dir: str, pkg_args: Namespace, xml_config: XmlConfig) -> str:
    """获取makeself压缩命令"""
    suffix = xml_config.package_attr.get("suffix")
    if suffix == "run":
        package_name = PackageName(xml_config.package_attr, pkg_args, xml_config.version)
        factory = create_makeself_pkg_params_factory(
            pkg_args.pkg_output_dir, package_name.getvalue(), get_comments(package_name)
        )
        params = factory(pkg_args.makeself_dir, xml_config.package_attr, pkg_args.independent_pkg)
        pack_cmd, err_msg = create_run_package_command(params)
        if err_msg:
            CommLog.cilog_error(err_msg)
            CommLog.cilog_error("create_run_command failed!")
            raise CompressError(package_name.getvalue())
        if pkg_args.independent_pkg:
            exec_pack_cmd(delivery_dir, pack_cmd, package_name.getvalue())
    else:
        CommLog.cilog_error("the repack type '%s' is not support!", suffix)
        sys.exit(FAIL)
    try:
        makeself_dir = os.path.join(TOP_DIR, "build/makeself.txt")
        with open(makeself_dir, "w") as f:
            f.write(pack_cmd)
    except Exception as exception:
        CommLog.cilog_error(f"save makeself.txt failed!{str(exception)}")
        sys.exit(FAIL)
    return package_name.getvalue()


def make_parse_option(args_: argparse.Namespace) -> ParseOption:
    """创建解析参数。"""

    return ParseOption(args_.os_arch, args_.pkg_version, args_.build_type, args_.package_check, args_.ext_name)


PrivatePackageOption = namedtuple(
    "PrivatePackageOption",
    [
        "os_arch",
        "package_suffix",
        "not_in_name",
        "pkg_version",
        "ext_name",
        "chip_name",
        "func_name",
        "version_dir",
        "disable_multi_version",
        "suffix",
    ],
)


class PackageOption(PrivatePackageOption):
    """打包配置参数。"""

    __slots__ = ()  # 优化内存，避免创建 __dict__

    def __new__(cls, *package_option_args, **kwargs):
        return super().__new__(cls, *package_option_args, **kwargs)


def generate_info_content(target_conf, ext_name) -> list[str]:
    """生成info内容。"""

    def toolchain_llvm_config() -> Iterator[tuple[str, str]]:
        if "llvm" in ext_name:
            yield "toolchain", "llvm"

    content_list = [f"{key}={value}" for key, value in chain(target_conf["content"].items(), toolchain_llvm_config())]
    return content_list


def generate_version_header_content(target_conf) -> Iterator[str]:
    """生成version_header内容。"""
    guard_name = target_conf["value"].replace(".", "_").upper()
    yield f"#ifndef {guard_name}"
    yield f"#define {guard_name}"
    yield ""
    for name, value in target_conf["content"].items():
        if name.endswith("_VERSION"):
            version_infos = get_cann_version_info(name, value)
            for version_name, version_value in version_infos:
                yield f"#define {version_name} {version_value}"
        else:
            yield f"#define {name} {value}"
    yield ""
    yield f"#endif /* {guard_name} */"
    yield ""


def generate_customized_file(target_conf, ext_name):
    filepath = os.path.join(TOP_DIR, "build", target_conf.get("value"))

    generator = target_conf.get("generator", "info")
    if generator == "version_header":
        content_list = generate_version_header_content(target_conf)
    else:
        content_list = generate_info_content(target_conf, ext_name)

    file_content = "\n".join(content_list)
    try:
        with open(filepath, "w") as file:
            file.write(file_content)
    except Exception as ex:
        CommLog.cilog_error(f"generate customized file {filepath} failed: {ex}!")
        return FAIL

    return SUCCESS


def get_module(target_config) -> str:
    """获取配置模块。"""
    module = target_config.get("module", "NA")
    return module if module else "NA"


def get_operation(operation, target_config) -> str:
    """获取操作类型。"""
    if operation in ("copy", "move") and target_config.get("entity") == "true":
        return "copy_entity"
    return operation


def get_permission(target_config) -> str:
    """获取配置权限。"""
    return target_config.get("install_mod", "NA")


def get_owner_group(target_config) -> str:
    """获取配置属主。"""
    # install_own的可能值为$username:$usergroup
    # 防止变量在install_common_parser.sh中，被eval展开，添加\转义$
    # 由于awk会消耗1个\，所以需要2个转义符
    return target_config.get("install_own", "NA").replace("$", "\\\\$")


def get_install_type(target_config) -> str:
    """获取安装类型。"""
    return target_config.get("install_type", "NA")


def get_softlink(target_config) -> list[str]:
    """获取配置软链。"""
    softlink_str = target_config.get("install_softlink")
    if not softlink_str:
        return []
    return softlink_str.split(";")


def get_feature(target_config) -> set[str]:
    """获取配置特性。"""
    return target_config["feature"]


def get_chip(target_config) -> set[str]:
    """获取配置芯片。"""
    return target_config["chip"]


def get_configurable(target_config) -> str:
    """获取配置是否为配置文件。"""
    return target_config.get("configurable", "FALSE")


def get_hash_value(target_config) -> str:
    """获取配置哈希值。"""
    return target_config.get("hash", "NA")


def get_block(target_config) -> str:
    """获取配置块信息。"""
    return target_config.get("name", "NA")


def get_pkg_inner_softlink(target_config) -> list[str]:
    """获取配置包内软链。"""
    softlink_str = target_config.get("pkg_inner_softlink")
    if not softlink_str:
        return []
    return softlink_str.split(";")


def parse_install_info(infos: list, operate_type, filter_key) -> Iterator[FileItem]:
    """根据配置解析生成安装信息。"""
    for target_config in infos:
        target_name = get_target_name(target_config)
        if target_config.get("optional") == "true" and operate_type in ("copy", "move"):
            path = os.path.join(TOP_DIR, DELIVERY_PATH, target_config.get("dst_path"))
            value = os.path.join(TOP_DIR, DELIVERY_PATH, target_config.get("dst_path"), target_name)
            if not os.path.exists(path):
                continue
            if not os.path.exists(value):
                continue
        if operate_type in ("copy", "move"):
            relative_path_in_pkg = os.path.join(target_config.get("dst_path"), target_name)
            relative_install_path = path_join(target_config.get("install_path"), target_name)
            is_dir = target_config.get("is_dir", False)
        elif operate_type == "mkdir":
            relative_path_in_pkg = "NA"
            relative_install_path = target_config.get("value")
            is_dir = False
        elif operate_type == "del":
            relative_path_in_pkg = "NA"
            relative_install_path = path_join(target_config.get("install_path"), target_name)
            is_dir = False
        else:
            raise UnknownOperateTypeError(f"unknown operate type {operate_type}")

        if relative_install_path is None:
            continue

        install_type = get_install_type(target_config)
        if any(key in install_type for key in filter_key):
            is_in_docker = "TRUE"
        else:
            is_in_docker = "FALSE"

        file_item = create_file_item(
            get_module(target_config),
            get_operation(operate_type, target_config),
            relative_path_in_pkg,
            relative_install_path,
            is_in_docker,
            get_permission(target_config),
            get_owner_group(target_config),
            install_type,
            get_softlink(target_config),
            get_feature(target_config),
            "N",
            get_configurable(target_config),
            get_hash_value(target_config),
            get_block(target_config),
            get_pkg_inner_softlink(target_config),
            get_chip(target_config),
            is_dir,
        )

        yield file_item


def execute_repack_process(
    xml_config: XmlConfig,
    delivery_dir: str,
    pkg_args: Namespace,
    package_name: PackageName = None,
    package_option: PackageOption = None,
):
    """
    功能描述: 执行打包流程(拷贝--->签名--->打包)
    返回值: SUCCESS/FAIL
    """
    release_dir = os.path.join(delivery_dir, xml_config.default_config.get("name", "default"))
    # 生成自定义文件
    for item in xml_config.generate_infos:
        if generate_customized_file(item, package_option.ext_name):
            return FAIL

    # 校验包中文件或目录大小
    if pkg_args.check_size == "True":
        limit_list, tag = processing_csv_file(
            release_dir, package_name.func_name, package_name.chip_name, pkg_args.build_type
        )
        if not tag:
            return FAIL
        if limit_list:
            abspath = os.path.abspath(release_dir)
            replace_path = abspath + "/"
            result = check_add_dir(replace_path, abspath, limit_list)
            if not result:
                return FAIL
    try:
        package_name = get_compress_cmd(pkg_args.pkg_output_dir, pkg_args, xml_config)
    except CompressError:
        return FAIL

    CommLog.cilog_info("package %s generate filelist.csv and makeself cmd successfully!", package_name)
    return SUCCESS


def check_path_is_conflict(xml_config):
    """
    功能描述: 检查打包时安装路径与软连接路径是否冲突
    参数: xml_config
    返回值: SUCCESS/FAIL
    """
    install_path_list = set()
    pkg_softlink_list = set()
    for item in xml_config.package_content_list:
        value_list = item.get("value").split("/")
        target_name = value_list[-1] if value_list[-1] else value_list[-2]
        if item.get("install_path"):
            install_path_list.add(os.path.join(item["install_path"], target_name))
        if item.get("pkg_inner_softlink"):
            pkg_softlink = item.get("pkg_inner_softlink")
            pkg_softlink_list.add(pkg_softlink)
    if install_path_list & pkg_softlink_list:
        CommLog.cilog_info("intersection:{}".format(install_path_list & pkg_softlink_list))
        CommLog.cilog_info("path conflicting: pkg_inner_softlink dir equals install_path!!")
        return FAIL
    return SUCCESS


def checksum_value(limit_value, release_dir):
    """
    功能描叙: 校验传入的文件或目录大小是否合格
    参数:
    limit_value: limit.csv中的一行数据如[compiler/bin, 3976, 110%]
    返回值: True/False
    """
    path = os.path.join(release_dir, limit_value[1])
    if len(limit_value) >= 7:
        try:
            max_value = int(limit_value[4])
        except ValueError:
            CommLog.cilog_error(f"{path} configuration is not standard., Please check limit.csv.")
            return True
    else:
        CommLog.cilog_error(f"{path} configuration is less than four, Please check limit.csv.")
        return True
    if not os.path.exists(path):
        CommLog.cilog_warning(f"{path} doesn't exist, Please check limit.csv.")
        return True
    size = 0
    for root, dirs, files in os.walk(path):
        size += os.path.getsize(root)
        for f in files:
            filepath = os.path.join(root, f)
            if os.path.islink(filepath):
                continue
            if not os.path.exists(filepath):
                continue
            size += os.path.getsize(os.path.join(root, f))
    if size == 0:
        size = os.path.getsize(path)
    if size > max_value * 1024:
        CommLog.cilog_error(f"\n{path} size {size} bytes exceeds maximum {max_value * 1024} bytes")
        return False
    return True


def processing_csv_file(release_dir, package_name, chip_name, build_type):
    """
    功能描叙: 处理limit.csv文件数据
    返回值: [],True/[],False
    """
    ret = True
    limit_list = []
    product = os.path.basename(os.path.dirname(release_dir))
    limit_path = os.path.join(pkg_utils.TOP_SOURCE_DIR, CONFIG_SCRIPT_PATH, "common/limit.csv")
    if not os.path.exists(limit_path):
        CommLog.cilog_warning(f"{limit_path} doesn't exist.")
        return limit_list, ret
    with open(limit_path) as file:
        reader = csv.reader(file)
        next(reader)
        for data in reader:
            if not data:
                CommLog.cilog_warning("The limit.csv file contains empty lines.")
                continue
            if is_match_line(package_name, chip_name, product, build_type, data):
                if data[1][-1] == "/":
                    limit_list.append(data[1][:-1])
                else:
                    limit_list.append(data[1])
                res = checksum_value(data, release_dir)
                if not res:
                    ret = False
    return limit_list, ret


def is_match_line(package_name, chip_name, product, build_type, data):
    return package_name == data[0] and chip_name == data[5] and product == data[6] and build_type == data[7].lower()


def check_add_dir(package_path, dirs, limit_list, ret=True):
    """
    功能描述: 校验新增目录
    参数: path, limit_list
    返回值: False/True
    """
    for limit_path in limit_list:
        if dirs == os.path.join(os.path.split(dirs)[0], limit_path):
            return ret
    for dir_file in os.listdir(dirs):
        path = os.path.join(dirs, dir_file)
        relative_path = path.replace(package_path, "")
        if os.path.isfile(path) and relative_path not in limit_list:
            CommLog.cilog_error(f"{path} is not in limit.csv file and is newly added.")
            ret = False
        elif os.path.isdir(path) and relative_path not in limit_list:
            ret = check_add_dir(package_path, path, limit_list, ret)
    return ret


def get_target_name(target_conf) -> str:
    """获取目标名。"""
    rename = target_conf.get("rename")
    if rename:
        return rename

    value_list = target_conf.get("value").split("/")
    target_name = value_list[-1] if value_list[-1] else value_list[-2]
    return target_name


def gen_file_install_list(xml_config: XmlConfig, filter_key) -> tuple[FileList, FileList]:
    """生成filelist列表。"""
    file_install_list = []

    dir_filelist = parse_install_info(xml_config.dir_install_list, "mkdir", filter_key)
    move_filelist = parse_install_info(xml_config.move_content_list, "move", filter_key)
    pkg_filelist = parse_install_info(xml_config.package_content_list, "copy", filter_key)
    gen_filelist = parse_install_info(xml_config.generate_infos, "copy", filter_key)
    # file_info中配置为文件夹，这里是被展开的文件,则需要单独删除
    del_filelist = parse_install_info(xml_config.expand_content_list, "del", filter_key)
    collect_filelist = list(chain(dir_filelist, move_filelist, pkg_filelist, gen_filelist))
    collect_filelist = list(xml_config.packer_config.fill_is_common_path(collect_filelist))
    all_filelist = list(chain(collect_filelist, del_filelist))
    for file_item in all_filelist:
        file_install_list.append(file_item)

    return file_install_list, []


def generate_filelist_file_by_xml_config(xml_config: XmlConfig, filter_key: list[str], package_check: bool):
    """生成文件列表文件。"""
    check_move = xml_config.package_attr.get("use_move", False)
    transform_nested_path_func = get_transform_nested_path_func(xml_config.package_attr.get("parallel") or check_move)
    check_features = xml_config.package_attr.get("check_features", False)

    file_install_list, [] = invoke(
        pipe(
            gen_file_install_list,
            partial(map, transform_nested_path_func),
            tuple,
        ),
        xml_config,
        filter_key,
    )
    generate_filelist(file_install_list, "filelist.csv")
    # 先生成再检查，有利于问题定位
    check_filelist(file_install_list, check_features, check_move)


def get_pkg_xml_relative_path(pkg_args: Namespace) -> str:
    """获取包配置文件相对路径。"""

    def parts():
        yield CONFIG_SCRIPT_PATH
        yield pkg_args.pkg_name
        if pkg_args.chip_scenes:
            yield pkg_args.chip_scenes
        # 可以通過build_rule指定xml_file，而且优先级高于默认值
        if pkg_args.xml_file:
            yield pkg_args.xml_file
        else:
            yield f"{pkg_args.pkg_name}.xml"

    return os.path.join(*parts())


def write_config_inc_var(name: str, package_attr: dict, file: TextIO):
    """向config.inc文件写入变量。"""
    if name in package_attr:
        value = str(package_attr[name]).lower()
        file.write(f"{name.upper()}={value}\n")


def generate_config_inc(package_attr: dict):
    """生成config.inc文件。"""
    if "parallel" not in package_attr and "parallel_limit" not in package_attr and "use_move" not in package_attr:
        return
    year = datetime.now(timezone.utc).year
    config_inc = os.path.join(TOP_DIR, "build", "config.inc")
    header = [
        "#!/bin/sh\n",
        "#----------------------------------------------------------------------------\n",
        f"# Copyright Huawei Technologies Co., Ltd. 2023-{year}. All rights reserved.\n",
        "#----------------------------------------------------------------------------\n",
        "\n",
    ]
    if os.path.isfile(config_inc):
        os.chmod(config_inc, 0o700)
    with open(config_inc, "w", encoding="utf-8") as file:
        file.writelines(header)
        write_config_inc_var("parallel", package_attr, file)
        write_config_inc_var("parallel_limit", package_attr, file)
        write_config_inc_var("use_move", package_attr, file)

    os.chmod(config_inc, 0o500)


def update_version_info(new_version: str):
    version_path = os.path.join(pkg_utils.TOP_DIR, "version.info")
    with open(version_path) as file:
        content = file.read()
        content = re.sub(r"Version=.*", f"Version={new_version}", content)
        content = re.sub(r"vension_dir=.*", f"version_dir={new_version}", content)
    with open(version_path, "w") as file:
        file.write(content)


def main(pkg_name="", xml_file="", main_args=None):
    """
    功能描述: 执行打包流程(解析配置--->生成文件列表--->执行拷贝/打包动作)
    参数: pkg_name, os_arch, type
    返回值: SUCCESS/FAIL
    """
    delivery_dir = os.path.join(TOP_DIR, DELIVERY_PATH)
    if not os.path.exists(delivery_dir):
        return FAIL

    config_relative_path = get_pkg_xml_relative_path(main_args)
    pkg_xml_file = os.path.join(pkg_utils.TOP_SOURCE_DIR, config_relative_path)
    parse_option = make_parse_option(main_args)
    if main_args.version_dir:
        update_version_info(main_args.version_dir)

    try:
        xml_config = parse_xml_config(pkg_xml_file, delivery_dir, parse_option, main_args)
    except ContainAsteriskError as ex:
        CommLog.cilog_error(f"Value contain '*' in {config_relative_path}. value is '{ex.value}'.")
        return FAIL

    if pkg_name in ["driver", "firmware"]:
        filter_key = ["all", "docker"]
    elif pkg_name in ["aicpu_kernels_device", "aicpu_kernels_host"]:
        filter_key = []
    else:
        filter_key = ["all", "run"]

    # 生成filelist.csv安装列表文件
    try:
        generate_filelist_file_by_xml_config(
            xml_config, filter_key, main_args.package_check or xml_config.package_attr.get("package_check")
        )
    except PackageNameEmptyError:
        CommLog.cilog_error(f"package name is empty in {xml_file}, please check it")
        return FAIL
    except GenerateFilelistError as ex:
        CommLog.cilog_error(
            f"generate filelist {ex.filename} failed!",
        )
        return FAIL
    except FilelistError as ex:
        CommLog.cilog_error("check filelist error! %s", str(ex))
        return FAIL

    generate_config_inc(xml_config.package_attr)

    if main_args.independent_pkg:
        src_file_path = os.path.join(TOP_DIR, "build", "filelist.csv")
        dst_file_path = os.path.join(main_args.pkg_output_dir, "share", "info", main_args.pkg_name, "script")
        shutil.copy(src_file_path, dst_file_path)

    package_option = PackageOption(
        main_args.os_arch,
        main_args.package_suffix,
        main_args.not_in_name,
        main_args.pkg_version,
        main_args.ext_name,
        chip_name=main_args.chip_name,
        func_name=main_args.func_name,
        version_dir=main_args.version_dir,
        disable_multi_version=main_args.disable_multi_version,
        suffix=main_args.suffix,
    )

    package_name = PackageName(xml_config.package_attr, main_args, xml_config.version)

    # 检查install_path与pkg_inner_softlink路径是否冲突，若冲突则报错
    if check_path_is_conflict(xml_config) == FAIL:
        return FAIL

    # 生成打包命令
    return execute_repack_process(
        xml_config, delivery_dir, main_args, package_name=package_name, package_option=package_option
    )


def args_parse():
    """
    功能描述 : 脚本入参解析
    参数 : 调用脚本的传参
    返回值 : 解析后的参数值
    """
    parser = argparse.ArgumentParser(description="This script is for package repack processing.")
    parser.add_argument(
        "-c",
        "--chip_scenes",
        metavar="chip_scenes",
        required=False,
        dest="chip_scenes",
        nargs="?",
        const="",
        default="",
        help="This parameter define chip id for package.",
    )
    parser.add_argument(
        "-n", "--pkg_name", metavar="pkg_name", required=False, help="This parameter define pkg_name for config_xml."
    )
    parser.add_argument(
        "-o",
        "--os_arch",
        metavar="os_arch",
        required=False,
        dest="os_arch",
        nargs="?",
        const="",
        default=None,
        help="This parameter define the package's os_arch",
    )
    parser.add_argument(
        "-t",
        "--type",
        metavar="type",
        required=False,
        dest="type",
        nargs="?",
        const="",
        default="repack",
        help="This parameter define this script's function",
    )
    parser.add_argument(
        "-i",
        "--not_in_name",
        metavar="not_in_name",
        required=False,
        dest="not_in_name",
        nargs="?",
        const="",
        default="",
        help="This parameter define the package's name not contain the element",
    )
    parser.add_argument(
        "-v",
        "--pkg_version",
        metavar="pkg_version",
        required=False,
        dest="pkg_version",
        nargs="?",
        const="",
        default="",
        help="This parameter define the version for package.",
    )
    parser.add_argument(
        "-e",
        "--ext_name",
        metavar="ext_name",
        required=False,
        dest="ext_name",
        nargs="?",
        const="",
        default="",
        help="This parameter define the package's ext_name",
    )
    parser.add_argument(
        "--package_suffix",
        nargs="?",
        const="none",
        default="none",
        help="This parameter define the package suffix, debug or none",
    )
    parser.add_argument(
        "--suffix",
        metavar="suffix",
        required=False,
        dest="suffix",
        nargs="?",
        const="",
        default=None,
        help="This parameter define the package suffix, for example such as tar.gz",
    )
    parser.add_argument(
        "-b",
        "--build_type",
        metavar="build_type",
        required=False,
        dest="build_type",
        nargs="?",
        const="",
        default="debug",
        help="This parameter define release type of package",
    )
    parser.add_argument(
        "-x",
        "--xml",
        metavar="xml_file",
        required=False,
        dest="xml_file",
        nargs="?",
        const="",
        default="",
        help="This parameter define xml file",
    )
    parser.add_argument(
        "--chip_name",
        metavar="chip_name",
        required=False,
        dest="chip_name",
        nargs="?",
        const=None,
        default=None,
        help="This parameter define package chip name, has higher priority than chip name in xml",
    )
    parser.add_argument(
        "--func_name",
        metavar="func_name",
        required=False,
        dest="func_name",
        nargs="?",
        const=None,
        default=None,
        help="This parameter define package func name, has higher priority than func name in xml",
    )
    parser.add_argument(
        "--source_root",
        metavar="source_root",
        required=False,
        dest="source_root",
        nargs="?",
        const="",
        help="source root dir.",
    )
    parser.add_argument(
        "--makeself_dir",
        metavar="makeself_dir",
        required=False,
        dest="makeself_dir",
        nargs="?",
        const="",
        help="makeself dir.",
    )
    parser.add_argument("--independent_pkg", action="store_true", help="Independent pkg.")
    parser.add_argument("--pkg-output-dir", default="", help="Package dirpath.")
    parser.add_argument("--version_dir", nargs="?", const="", default="", help="Set version dir.")
    parser.add_argument("--tag", metavar="tag", nargs="?", const="", default="")
    parser.add_argument("--disable-multi-version", action="store_true", help="Disable multi version.")
    # 检查打包配置
    parser.add_argument("--package-check", action="store_true", help="check package config.")
    parser.add_argument("--check_size", nargs="?", const="", default="", help="Check the size of a file or directory.")
    parser.add_argument("--pkg-name-style", metavar="pkg_name_style", default="common", help="Package name style.")
    return parser.parse_args()


if __name__ == "__main__":
    CommLog.cilog_info("%s", " ".join(sys.argv))
    args = args_parse()
    try:
        if args.source_root:
            pkg_utils.TOP_SOURCE_DIR = args.source_root
        if args.build_type == "":
            args.build_type = "debug"
        else:
            args.build_type = args.build_type.lower()
        status = main(args.pkg_name, args.xml_file, main_args=args)
    except Exception as e:
        CommLog.cilog_error("exception is occurred (%s)!", e)
        CommLog.cilog_info("%s", traceback.format_exc())
        status = FAIL
    sys.exit(status)