# Copyright (c) 2025 Huawei Technologies Co., Ltd.
# openUBMC is licensed under Mulan PSL v2.
# You can use this software according to the terms and conditions of the Mulan PSL v2.
# You may obtain a copy of Mulan PSL v2 at:
#         http://license.coscl.org.cn/MulanPSL2
# 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 FIT FOR A PARTICULAR PURPOSE.
# See the Mulan PSL v2 for more details.

import os
import fnmatch
import shutil
from conanbase import ConanBase
from conan.tools.scm import Git, Version
from conan.tools.meson import Meson, MesonToolchain
from conan.tools.env import VirtualBuildEnv
from conan.tools.files import copy

required_conan_version = ">=2.13.0"


class AppConan(ConanBase):
    language = "c++"
    generators = "CMakeDeps", "VirtualBuildEnv", "PkgConfigDeps"
    # ─── 编译时间优化:跳过 conan 默认的 "Copying sources to build folder" 步骤
    # 日志实测该步骤约占 5 分钟(4:25 → 9:28),直接在 source_folder 原地构建即可
    no_copy_source = True
    options = {
        "asan": [True, False],
        "gcov": [True, False],
        "test": [True, False],
        "enable_luajit": [True, False],
        "unidev": [True, False],
        "chipv2_enable": [True, False],
        "feature_ssu": [True, False],
        "feature_rs485": [True, False],
        "feature_mellanox": [True, False],
    }
    default_options = {
        "asan": False,
        "gcov": False,
        "test": False,
        "enable_luajit": False,
        "unidev": False,
        "chipv2_enable": False,
        "feature_ssu": False,
        "feature_rs485": False,
        "feature_mellanox": True,
    }

    def requirements(self):
        super().requirements()
        if self.options.test:
            self.requires("gtest/[>=1.14.0]@openubmc/stable")

    def package_id(self):
        base_package_id = getattr(
            super(),
            "package_id",
            None,
        )
        if callable(base_package_id):
            base_package_id()

        # 1.130.14和1.130.60使用不同BCAL接口,
        # patch版本必须参与component_drivers包ID计算。
        self.info.requires[
            "libsoc_adapter"
        ].patch_mode()

    # ─── 编译时间优化:源码排除集
    # 基类 conanbase.ConanBase.add_excludes 已支持:
    #   1) glob 通配符(走 fnmatch,不再做 os.path.exists 过滤)
    #   2) 内置 BMC 业务仓常见构建/缓存/日志的保底排除集
    # 因此理论上无需再在子类显式列 _source_excludes。
    #
    # 但 conanbase.py 会被 bingo/bmcgo 按模板重新生成覆盖(见 conanbase.py 顶部
    # 注释),一旦模板回退旧逻辑,这里的 override 是唯一防线——故保留为兼容层,
    # 仅列出业务仓独有 / 比基类默认更激进的条目,避免与基类重复。
    _source_excludes_extra = [
        "build.sh",
        "coverage_filtered.info", "coverage.info",
        "build_clean_compare.*",
        "build_optimized.log",
        ".cache",
        ".cache/*",
    ]

    def source(self):
        sources = self.conan_data["sources"][self.version]
        if sources["url"] and sources["branch"]:
            Git(self).fetch_commit(url=sources["url"], commit=sources["branch"].split("/")[-1])
            return
        excludes = list(self._source_excludes_extra)
        # 叠加基类默认排除;若基类尚未升级(老模板)则手动补齐关键项
        base_excludes = getattr(self, "_DEFAULT_SOURCE_EXCLUDES", None)
        if base_excludes:
            for item in base_excludes:
                if item not in excludes:
                    excludes.append(item)
        else:
            # 兼容:老版 conanbase.py 的保底列表
            for item in ("builddir*", "build", ".build", "temp", "temp/*",
                         "*.log", "bingo-*.txt",
                         ".libmcpp_prebuilt", ".ccache_wrapper", ".pkg-config",
                         ".cache", ".cache/*",
                         ".vscode", ".DS_Store", ".git", ".gitignore"):
                if item not in excludes:
                    excludes.append(item)
        copy(self, "*", src=sources["pwd"], dst=".", excludes=excludes)

    def package_info(self):
        # 根据架构设置库目录
        if self.settings.arch == "armv8" or self.settings.arch == "x86_64":
            self.cpp_info.libdirs = ["usr/lib64"]
            self.env_info.LD_LIBRARY_PATH.append(os.path.join(self.package_folder, "usr/lib64"))
            libdir = "usr/lib64"
        else:
            self.cpp_info.libdirs = ["usr/lib"]
            self.env_info.LD_LIBRARY_PATH.append(os.path.join(self.package_folder, "usr/lib"))
            libdir = "usr/lib"

        self.env_info.PATH.append(os.path.join(self.package_folder, "opt/bmc/apps/libmcpp"))

        self.cpp_info.includedirs = [
            "internal", "internal/bus/bus_base",
            "internal/bus/bus_i2c", "internal/bus/bus_hisport",
            "internal/chip/chip_base", "internal/chip/chip_lm75",
            "internal/chip/chip_pca9545", "internal/chip/chip_pca9555",
        ]
        # 配置libInternal的pkg-config
        self.cpp_info.components["internal"].libs = ["Internal", "dev_smbus", "dev_protocol"]
        self.cpp_info.components["internal"].libdirs = [libdir]
        self.cpp_info.components["internal"].set_property("pkg_config_name", "Internal")
        self.cpp_info.components["internal"].requires = ["libmcpp::libmcpp", "libsoc_adapter::libsoc_adapter"]

        # Interface_Chip is implemented by the loadable Chip driver, while its
        # generated base class is implemented by libdevice_tree. Export the
        # complete public C++ link surface as a dedicated component instead of
        # making every Internal consumer link a concrete chip driver.
        self.cpp_info.components["chip"].libs = ["Chip", "device_tree"]
        self.cpp_info.components["chip"].libdirs = ["opt/bmc/drivers", libdir]
        self.cpp_info.components["chip"].set_property("pkg_config_name", "Chip")
        self.cpp_info.components["chip"].requires = ["internal"]
        if self.options.test:
            self.cpp_info.components["gtest"].requires = ["gtest::gtest"]

    # 基于meson构建的基类,适用于libmcpp项目
    def layout(self):
        super().layout()
        self.cpp.package.libdirs = ["usr/lib64"]

    def generate(self):
        tc = MesonToolchain(self, "ninja")
        ms = VirtualBuildEnv(self)

        libsoc_adapter_dep = self.dependencies.get(
            "libsoc_adapter"
        )

        libsoc_adapter_version = (
            str(libsoc_adapter_dep.ref.version)
            if libsoc_adapter_dep is not None
            else "0.0.0"
        )

        jtag_sec_mode_bcal = (
            libsoc_adapter_dep is not None
            and Version(libsoc_adapter_version)
            >= Version("1.130.60")
        )

        tc.project_options[
            "jtag_sec_mode_bcal"
        ] = jtag_sec_mode_bcal

        self.output.info(
            "JTAG SecModeType BCAL adapter: "
            f"{'enabled' if jtag_sec_mode_bcal else 'disabled'}, "
            f"libsoc_adapter={libsoc_adapter_version}, "
            "minimum=1.130.60"
        )

        if self.options.asan:
            tc.extra_cxxflags.append("-fsanitize=address")
            tc.extra_cxxflags.append("-fno-omit-frame-pointer")
            tc.extra_ldflags.append("-fsanitize=address")
            # 保留符号表供 ASAN/LSAN 符号化堆栈,否则泄漏报告只能显示 模块+偏移
            tc.project_options["strip_binaries"] = "false"

        tc.extra_ldflags.append("-lstdc++fs")
        tc.extra_cxxflags.append("-Wno-unused-variable")
        tc.extra_cxxflags.append("-Wno-unused-parameter")
        tc.extra_cxxflags.append("-Wno-sign-compare")
        tc.extra_cxxflags.append("-fpermissive")
        tc.extra_cxxflags.append("-Wno-pedantic")
        tc.extra_cxxflags.append("-fno-strict-aliasing")
        tc.extra_cxxflags.append("-Wno-deprecated-copy")

        # 添加sysroot参数用于交叉编译
        pkg_path = ms.vars().get("PKG_CONFIG_PATH")
        if pkg_path:
            tc.pkg_config_path += ":" + pkg_path

        os.environ["PKG_CONFIG"] = "/usr/bin/pkg-config"

        if self.settings.arch == "armv8" or self.settings.arch == "x86_64":
            tc.project_options["libdir"] = 'usr/lib64'
        else:
            tc.project_options["libdir"] = 'usr/lib'
        tc.project_options["enable_conan_compile"] = "true"

        # 设置meson构建选项
        if self.options.test:
            tc.project_options["tests"] = "true"
        else:
            tc.project_options["tests"] = "false"
        tc.project_options["meson_build"] = "false"

        if self.options.unidev:
            tc.project_options["unidev"] = "true"
        else:
            tc.project_options["unidev"] = "false"

        if self.options.chipv2_enable:
            tc.project_options["chipv2_enable"] = "true"
        else:
            tc.project_options["chipv2_enable"] = "false"

        # SSU 管理功能编译裁剪:关闭时 drivers/ssu_card 与 libraries/ssu_oob 不参与编译
        if self.options.feature_ssu:
            tc.project_options["feature_ssu"] = "true"
        else:
            tc.project_options["feature_ssu"] = "false"

        # CSR2 RS485 风扇驱动编译裁剪:关闭时 drivers/fan/rs485(libfan_rs485.so)不参与编译
        if self.options.feature_rs485:
            tc.project_options["feature_rs485"] = "true"
        else:
            tc.project_options["feature_rs485"] = "false"

        # Mellanox 网卡驱动编译裁剪:关闭时 drivers/pcie_nic_card/mellanox 不参与编译
        if self.options.feature_mellanox:
            tc.project_options["feature_mellanox"] = "true"
        else:
            tc.project_options["feature_mellanox"] = "false"

        # ─── 编译时间优化(对齐 docs/Q2-编译时间优化.md 本地 smart_build.sh -X 策略)───
        # 1) Unity Build:主工程合并 TU,CI 编译步数 528 → ~100,预计 -40%
        #    3 个多厂商库(pmbus/ncsi_over_mctp/nvme)+ 60 个 tests/**/meson.build
        #    已通过 override_options:['unity=off'] 豁免冲突(commit 441e662)
        #    通过环境变量 CONAN_UNITY=0 可一键回退
        if os.environ.get("CONAN_UNITY", "1") == "1":
            tc.project_options["unity"] = "on"
            tc.project_options["unity_size"] = os.environ.get("CONAN_UNITY_SIZE", "2")

        # 2) 显式透传 fast_debug_info / use_mold / inlines_hidden 到 meson
        #    (conan 的 buildtype 映射可能覆盖 meson_options.txt 的默认值)
        #    asan 时关闭 fast_debug_info:gcc-9 libasan 固定用 libbacktrace 符号化,
        #    不支持 -gsplit-dwarf 的 .dwo 侧车文件,行号解不出来只能显示 模块+偏移
        if self.options.asan:
            tc.project_options["fast_debug_info"] = "false"
        else:
            tc.project_options["fast_debug_info"] = "true"
        tc.project_options["use_mold"] = "true"
        tc.project_options["inlines_hidden"] = "true"

        # 3) 链接期 ICF(产物体积优化,实测与 inline 隐藏合计 -7.9%,
        #    见 docs/Q1-动态库so大小优化.md 2.5/2.6 节)
        tc.project_options["use_icf"] = "true"


        if self.settings.arch in ["armv8"]:
            pkg_config_path = ms.vars().get("PKG_CONFIG_PATH")
            if pkg_config_path:
                tc.properties["pkg_config_libdir"] = pkg_config_path.split(":")

        # 设置debug编译时的优化级别为-Os
        if self.settings.build_type == "Debug":
            tc.extra_cxxflags.append("-Os")
            tc.extra_cflags.append("-Os")
        if self.options.asan:
            tc.extra_cxxflags.append("-fsanitize=address")
            tc.extra_cxxflags.append("-fsanitize-recover=address")
            tc.extra_cxxflags.append("-fno-omit-frame-pointer")
            tc.extra_cxxflags.append("-fno-stack-protector")
            tc.extra_cxxflags.append("-O1")
            tc.extra_cflags.append("-O1")
            tc.extra_ldflags.append("-fsanitize=address")

        tc.generate()
        # 让本 recipe 后续的 Conan Meson helper / meson test 默认值跟主编译同一套 jobs。
        # 依赖包在 generate() 之前已构建,不受这里影响;本容器 Conan cpu_count() 已读 cpu.max。
        self._apply_parallelism()

    def _clamp_build_jobs(self, jobs):
        """并发数至少为 1,不设固定硬上限,由内存/CPU 预算决定。"""
        return 1 if jobs < 1 else jobs

    def _apply_parallelism(self, jobs=None):
        """把算出的并发写进 Conan conf 与 meson test 环境,堵住 -j nproc 漏口。"""
        if jobs is None:
            jobs = getattr(self, "_cached_build_jobs", None)
            if jobs is None:
                jobs = self._calculate_build_jobs()
        self._cached_build_jobs = jobs
        try:
            self.conf.define("tools.build:jobs", jobs)
        except Exception:
            pass
        os.environ["MESON_TESTTHREADS"] = str(jobs)
        return jobs

    def _cgroup_memory_limit_gb(self):
        """读取 cgroup 内存上限(GiB)。无限制或读失败返回 0。"""
        for path in ("/sys/fs/cgroup/memory.max",
                     "/sys/fs/cgroup/memory/memory.limit_in_bytes"):
            try:
                raw = open(path).read().strip()
                if not raw or raw == "max":
                    continue
                nbytes = int(raw)
                if nbytes <= 0:
                    continue
                gb = nbytes // 1024 // 1024 // 1024
                # cgroup v1 无限制时常写成 ~8EiB
                if 0 < gb < 1024:
                    return gb
            except (EnvironmentError, ValueError):
                continue
        return 0

    def _cgroup_cpu_quota(self):
        """读取 cgroup CFS CPU 配额(核数)。无限制或读失败返回 0。"""
        try:
            if os.path.exists("/sys/fs/cgroup/cgroup.controllers"):
                with open("/sys/fs/cgroup/cpu.max") as f:
                    parts = f.read().strip().split()
                if parts and parts[0] != "max":
                    quota = int(parts[0])
                    period = int(parts[1]) if len(parts) > 1 else 100_000
                    if quota > 0 and period > 0:
                        return (quota + period - 1) // period
            else:
                with open("/sys/fs/cgroup/cpu/cpu.cfs_quota_us") as f:
                    quota = int(f.read().strip())
                with open("/sys/fs/cgroup/cpu/cpu.cfs_period_us") as f:
                    period = int(f.read().strip())
                if quota > 0 and period > 0:
                    return (quota + period - 1) // period
        except (EnvironmentError, TypeError, ValueError):
            pass
        return 0

    def _calculate_build_jobs(self):
        """
        计算 bingo build / meson compile / meson test 并发数。

        场景策略:
          - BUILD_JOBS:强制覆盖,至少为 1
          - 一律走内存与 CPU 取 min。不再把 CI / BUILD_NUMBER 当成「铺满 nproc」:
            产品 bingo 和 Jenkins 常带 BUILD_NUMBER,本容器会被误判成 -j64。
            独享 CI 节点请显式 BUILD_JOBS=N,或把节点上错误的 cpu.max 配正确。
            内存同时看 MemAvailable 和 cgroup memory.max。
            CPU 认 cpuset;若有 cpu.max CFS 配额,按配额铺满(8 核 → -j8),不超额。
        """
        import multiprocessing

        env_jobs = os.environ.get("BUILD_JOBS")
        if env_jobs:
            try:
                return self._clamp_build_jobs(int(env_jobs))
            except ValueError:
                pass

        physical_cores = multiprocessing.cpu_count()

        cpu_cores = physical_cores
        try:
            with open("/sys/fs/cgroup/cpuset.cpus.effective") as f:
                cpuset_str = f.read().strip()
            if cpuset_str:
                cpuset_count = 0
                for part in cpuset_str.split(","):
                    if "-" in part:
                        start, end = part.split("-", 1)
                        cpuset_count += int(end) - int(start) + 1
                    else:
                        cpuset_count += 1
                if 0 < cpuset_count < cpu_cores:
                    cpu_cores = cpuset_count
        except (EnvironmentError, TypeError, ValueError):
            pass

        available_mem_gb = 0
        swap_total_gb = 0
        try:
            with open("/proc/meminfo") as f:
                for line in f:
                    if line.startswith("MemAvailable:"):
                        available_mem_gb = int(line.split()[1]) // 1024 // 1024
                    elif line.startswith("SwapTotal:"):
                        swap_total_gb = int(line.split()[1]) // 1024 // 1024
        except (EnvironmentError, ValueError):
            pass

        mem_budget_gb = os.environ.get("SMART_BUILD_MEM_BUDGET_GB")
        if mem_budget_gb:
            try:
                mem_budget_gb = int(mem_budget_gb)
            except ValueError:
                mem_budget_gb = min(available_mem_gb, 40)
        else:
            mem_budget_gb = min(available_mem_gb, 40)
            cgroup_mem_gb = self._cgroup_memory_limit_gb()
            if 0 < cgroup_mem_gb < mem_budget_gb:
                mem_budget_gb = cgroup_mem_gb

        # 默认 1200MB:与 Conan cmake --build / bingo_tools 同口径,
        # 40GiB 无 swap → mem_based=30;勿用 2000 否则会落到 -j18。
        mem_per_job_mb = os.environ.get("SMART_BUILD_MEM_PER_JOB_MB", "1200")
        try:
            mem_per_job_mb = int(mem_per_job_mb)
        except ValueError:
            mem_per_job_mb = 1200

        mem_based_jobs = (mem_budget_gb * 1024) // mem_per_job_mb
        if swap_total_gb == 0:
            mem_based_jobs = mem_based_jobs * 9 // 10

        # CPU 预算:有 CFS 配额时按配额铺满,不超额(cpu.max=8 → -j8)。
        cpu_quota = self._cgroup_cpu_quota()
        if cpu_quota > 0:
            cpu_based_jobs = cpu_quota
            if cpu_based_jobs > cpu_cores:
                cpu_based_jobs = cpu_cores
        else:
            cpu_based_jobs = cpu_cores

        jobs = mem_based_jobs if mem_based_jobs < cpu_based_jobs else cpu_based_jobs
        jobs = self._clamp_build_jobs(jobs)
        print(f"[INFO] build jobs={jobs} (mem_based={mem_based_jobs}, "
              f"cpu_based={cpu_based_jobs}, cpu_quota={cpu_quota or 'unlimited'}, "
              f"mem_budget_gb={mem_budget_gb})")
        return jobs

    def _calculate_test_jobs(self):
        """meson test 并发:SMART_BUILD_TEST_JOBS 可单独覆盖,否则与编译同一套算法。"""
        env_jobs = os.environ.get("SMART_BUILD_TEST_JOBS")
        if env_jobs:
            try:
                return self._apply_parallelism(self._clamp_build_jobs(int(env_jobs)))
            except ValueError:
                pass
        return self._apply_parallelism()

    def build(self):
        meson = Meson(self)
        buildfile = os.path.join(self.build_folder, "build.ninja")
        if not os.path.exists(buildfile):
            meson.configure()

        jobs = self._apply_parallelism()

        last_error = None
        for i in range(10):
            try:
                self.run(f'meson compile -C "{self.build_folder}" -j{jobs}')
                last_error = None
                break
            except Exception as e:
                last_error = e
                print(f"[WARNING] 编译失败: {e}")
                continue
        if last_error is not None:
            raise last_error

    def test(self):
        import glob
        import shlex
        import subprocess
        if self.options.asan:
            # ASAN 日志输出到源码目录的 temp/asan,避免混在 testlog.txt 中
            source_folder = os.environ.get("PWD", "") or self.source_folder
            asan_log_dir = os.path.join(source_folder, "temp", "asan")
            os.environ["ASAN_OPTIONS"] = f"log_path={asan_log_dir}/asan.log:detect_leaks=1:halt_on_error=0"
            lsan_suppressions_path = f"{asan_log_dir}/lsan_suppressions.txt"
            if os.path.exists(lsan_suppressions_path):
                os.environ["LSAN_OPTIONS"] = f"suppressions={lsan_suppressions_path}"

        runtime_lib_dirs = [
            os.path.join(self.build_folder, "usr/lib64"),
            os.path.join(self.build_folder, "opt/bmc/drivers"),
            os.path.join(self.build_folder, "gen"),
        ]
        for pc_file in glob.glob(os.path.join(self.build_folder, "generators", "*.pc")):
            prefix = ""
            libdir = ""
            with open(pc_file, encoding="utf-8") as file:
                for line in file:
                    line = line.strip()
                    if line.startswith("prefix="):
                        prefix = line.split("=", 1)[1]
                    elif line.startswith("libdir="):
                        libdir = line.split("=", 1)[1]
            if libdir:
                libdir = libdir.replace("${prefix}", prefix)
                if libdir not in runtime_lib_dirs:
                    runtime_lib_dirs.append(libdir)

        old_ld_path = os.environ.get("LD_LIBRARY_PATH", "")
        os.environ["LD_LIBRARY_PATH"] = ":".join(runtime_lib_dirs + ([old_ld_path] if old_ld_path else []))
        runtime_ld_path = ":".join(runtime_lib_dirs)

        install_cmd = [
            "meson",
            "install",
            "-C",
            self.build_folder,
            "--no-rebuild",
            "--destdir",
            self.build_folder,
        ]
        self.output.info(f"准备 Meson 测试运行时产物: {' '.join(install_cmd)}")
        install_result = subprocess.run(install_cmd, capture_output=False, text=True)
        if install_result.returncode != 0:
            raise Exception("Meson 测试运行时产物准备失败")

        # 清除 meson install 产出的 include/ 目录
        # 它会干扰 include_directories('include') 在 Regenerate 时的解析,
        # 导致首次 configure 和 Regenerate 产生不同的编译命令,触发全量重编译
        inc_dir = os.path.join(self.build_folder, "include")
        if os.path.isdir(inc_dir):
            shutil.rmtree(inc_dir)

        wrapper = os.path.join(self.build_folder, "meson_test_runtime_wrapper.sh")
        with open(wrapper, "w", encoding="utf-8") as file:
            file.write("#!/bin/sh\n")
            file.write(f"export LD_LIBRARY_PATH={shlex.quote(runtime_ld_path)}:$LD_LIBRARY_PATH\n")
            file.write('exec "$@"\n')
        os.chmod(wrapper, 0o755)

        cmd = [
            "meson",
            "test",
            "-C",
            self.build_folder,
            "-v",
            "--no-rebuild",
            "--wrapper",
            wrapper,
        ]

        filter_arg = os.environ.get("MCLI_TEST_FILTER")
        if filter_arg:
            cmd.extend(["--suite", filter_arg])

        test_args_str = os.environ.get("MCLI_TEST_ARGS")
        extra_args = shlex.split(test_args_str) if test_args_str else []
        has_num_proc = any(
            arg == "--num-processes" or arg.startswith("--num-processes=")
            or arg == "-j" or (arg.startswith("-j") and arg[2:].isdigit())
            for arg in extra_args
        )
        if not has_num_proc:
            test_jobs = self._calculate_test_jobs()
            cmd.extend(["--num-processes", str(test_jobs)])
        cmd.extend(extra_args)

        self.output.info(f"运行 Meson 测试: {' '.join(cmd)}")
        result = subprocess.run(cmd, capture_output=False, text=True)
        if result.returncode != 0:
            raise Exception("Meson 测试失败")

    def package(self):
        self._apply_parallelism()
        # meson install 默认会先 ninja 全量 rebuild,且不传 -j,
        # ninja 按宿主 nproc(本机 64)跑,把主编译的 -j8 冲掉。
        # build() 已经 meson compile -jN,这里禁止二次 rebuild。
        # conan 2.x 的 Meson.install() 不再支持 cli_args 参数,直接调用 meson 命令。
        # 必须带 --destdir package_folder,否则会安装到宿主 prefix(/usr 等),
        # 导致打包产物里没有任何 so/可执行文件
        self.run(f"meson install --no-rebuild -C {self.build_folder} --destdir {self.package_folder}")
        copy(self, "permissions.ini", src=self.source_folder, dst=self.package_folder)
        copy(self, "model.json", src=os.path.join(self.source_folder, "mds"),
             dst=os.path.join(self.package_folder, "include/mds"))
        copy(self, "service.json", src=os.path.join(self.source_folder, "mds"),
             dst=os.path.join(self.package_folder, "include/mds"))
        copy(self, "*", src=os.path.join(self.source_folder, "include"),
             dst=os.path.join(self.package_folder, "include"))
        if self.options.test and os.getenv('TRANSTOBIN') is None:
            return

        copy(self, "*.sr", src=os.path.join(self.source_folder, "./drivers"),
             dst=os.path.join(self.package_folder, "include/drivers"))
        copy(self, "customization.py", src=os.path.join(self.source_folder, "./include"),
             dst=os.path.join(self.package_folder, "include"))

        os.chdir(self.package_folder)

        # 对Debug模式编译生成的文件进行strip处理
        # asan 构建豁免:保留符号表供 ASAN/LSAN 符号化堆栈
        if self.settings.build_type == "Debug" and not self.options.asan:
            self._strip_debug_files()

    def _strip_debug_files(self):
        """对Debug模式编译生成的文件进行strip处理"""
        import subprocess
        import stat

        # 根据架构确定strip工具
        if self.settings.arch == "armv8":
            strip_tool = "aarch64-target-linux-gnu-strip"
        elif self.settings.arch == "x86_64":
            strip_tool = "strip"
        else:
            strip_tool = "strip"

        # 查找需要strip的文件
        lib_dirs = []
        if self.settings.arch == "armv8" or self.settings.arch == "x86_64":
            lib_dirs.append("usr/lib64")
        else:
            lib_dirs.append("usr/lib")

        # 添加可执行文件和驱动库目录
        bin_dirs = ["opt/bmc/apps/component_drivers", "opt/bmc/drivers"]

        all_dirs = lib_dirs + bin_dirs

        for directory in all_dirs:
            dir_path = os.path.join(self.package_folder, directory)
            if not os.path.exists(dir_path):
                continue

            for root, dirs, files in os.walk(dir_path):
                for file in files:
                    file_path = os.path.join(root, file)

                    # 检查文件是否为可执行文件或共享库
                    try:
                        if os.path.isfile(file_path) and not os.path.islink(file_path):
                            # 检查文件类型
                            result = subprocess.run(["file", file_path],
                                                  capture_output=True, text=True, timeout=10)
                            if result.returncode == 0:
                                file_type = result.stdout.lower()
                                if ("executable" in file_type or "current ar archive" in file_type or
                                    "shared object" in file_type or
                                    "dynamically linked" in file_type):
                                    # 执行strip操作
                                    self.run(f"{strip_tool} -s {file_path}")
                    except Exception as e:
                        print(f"Warning: Error processing {file_path}: {e}")
                        continue