#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mount.h>
#include <sys/xattr.h>
#include <sys/statfs.h>
#include <dirent.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <limits.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int setns(int fd, int nstype);

/*==============================================================================
 * 常量 & 宏
 *============================================================================*/

#define MAGIC_MOUNT_VERSION    "0.1.0"

#define DEFAULT_MOUNT_SOURCE   "KSU"
#define DEFAULT_MODULE_DIR     "/data/adb/modules"
#define DEFAULT_TEMP_DIR       "/dev/.magic_mount"   // fallback

#define DISABLE_FILE_NAME      "disable"
#define REMOVE_FILE_NAME       "remove"
#define SKIP_MOUNT_FILE_NAME   "skip_mount"

#define REPLACE_DIR_XATTR      "trusted.overlay.opaque"
#define SELINUX_XATTR          "security.selinux"

#ifndef PATH_MAX
#define PATH_MAX 4096
#endif

#ifndef TMPFS_MAGIC
#define TMPFS_MAGIC 0x01021994
#endif

#define UNUSED(x) (void)(x)

/*==============================================================================
 * 统计信息 & 全局配置
 *============================================================================*/

typedef struct {
    int modules_total;
    int nodes_total;
    int nodes_mounted;
    int nodes_skipped;
    int nodes_whiteout;
    int nodes_fail;
} MountStats;

static MountStats g_stats = {0};

static const char *g_module_dir   = DEFAULT_MODULE_DIR;
static const char *g_mount_source = DEFAULT_MOUNT_SOURCE;
static FILE       *g_log_file     = NULL;   // NULL => stderr
static int         g_log_level    = 2;      // 0=ERROR,1=WARN,2=INFO,3=DEBUG

/* 记录发生失败的模块名 & 额外分区列表 */
static char **g_failed_modules       = NULL;
static int    g_failed_modules_count = 0;

static char **g_extra_parts          = NULL; // 额外分区名，如 "my_custom"
static int    g_extra_parts_count    = 0;

/*==============================================================================
 * 日志
 *============================================================================*/

static void vlog(const char *lv, const char *fmt, va_list ap) {
    FILE *out = g_log_file ? g_log_file : stderr;
    fprintf(out, "[%s] ", lv);
    vfprintf(out, fmt, ap);
    fputc('\n', out);
    fflush(out);
}

static void log_msg(const char *lv, const char *fmt, ...) {
    va_list ap;
    va_start(ap, fmt);
    vlog(lv, fmt, ap);
    va_end(ap);
}

#define LV_ERROR 0
#define LV_WARN  1
#define LV_INFO  2
#define LV_DEBUG 3

#define LOG(lv, ...)                                                      \
    do {                                                                  \
        if ((lv) <= g_log_level)                                          \
            log_msg((lv)==LV_ERROR?"ERROR":                               \
                    (lv)==LV_WARN ?"WARN":                                \
                    (lv)==LV_INFO ?"INFO":"DEBUG",                        \
                    __VA_ARGS__);                                         \
    } while (0)

#define LOGE(...) LOG(LV_ERROR, __VA_ARGS__)
#define LOGW(...) LOG(LV_WARN,  __VA_ARGS__)
#define LOGI(...) LOG(LV_INFO,  __VA_ARGS__)
#define LOGD(...) LOG(LV_DEBUG, __VA_ARGS__)

/*==============================================================================
 * 工具函数
 *============================================================================*/

static int path_join(const char *base, const char *name,
                     char *buf, size_t n)
{
    if (!base) { errno = EINVAL; return -1; }

    if (!name || !name[0]) {
        if (snprintf(buf, n, "%s", base) >= (int)n) {
            errno = ENAMETOOLONG;
            return -1;
        }
        return 0;
    }

    if (!base[0] || (base[0]=='/' && !base[1])) {
        if (snprintf(buf, n, "/%s", name) >= (int)n) {
            errno = ENAMETOOLONG;
            return -1;
        }
    } else {
        size_t len = strlen(base);
        if (base[len-1] == '/') {
            if (snprintf(buf, n, "%s%s", base, name) >= (int)n) {
                errno = ENAMETOOLONG;
                return -1;
            }
        } else {
            if (snprintf(buf, n, "%s/%s", base, name) >= (int)n) {
                errno = ENAMETOOLONG;
                return -1;
            }
        }
    }
    return 0;
}

static bool path_exists(const char *p) {
    struct stat st;
    return (stat(p, &st) == 0);
}

static bool path_is_dir(const char *p) {
    struct stat st;
    return (stat(p, &st) == 0) && S_ISDIR(st.st_mode);
}

static bool path_is_symlink(const char *p) {
    struct stat st;
    return (lstat(p, &st) == 0) && S_ISLNK(st.st_mode);
}

static int mkdir_p(const char *dir) {
    if (!dir || !dir[0]) {
        errno = EINVAL;
        return -1;
    }

    struct stat st;
    if (stat(dir, &st) == 0) {
        if (S_ISDIR(st.st_mode)) return 0;
        LOGE("%s is not directory", dir);
        errno = ENOTDIR;
        return -1;
    }

    char tmp[PATH_MAX];
    if (strlen(dir) >= sizeof(tmp)) {
        errno = ENAMETOOLONG;
        return -1;
    }

    strcpy(tmp, dir);
    char *s = strrchr(tmp, '/');
    if (s && s != tmp) {
        *s = 0;
        if (mkdir_p(tmp) != 0) return -1;
    }

    if (mkdir(dir, 0755) == 0 || errno == EEXIST) return 0;

    LOGE("mkdir %s: %s", dir, strerror(errno));
    return -1;
}

static bool is_rw_tmpfs(const char *path) {
    if (!path_is_dir(path)) return false;

    struct statfs s;
    if (statfs(path, &s) < 0) return false;
    if ((unsigned long)s.f_type != (unsigned long)TMPFS_MAGIC) return false;

    char tmpl[PATH_MAX];
    if (path_join(path, ".magic_mount_testXXXXXX", tmpl, sizeof(tmpl)) != 0)
        return false;

    int fd = mkstemp(tmpl);
    if (fd < 0) return false;
    close(fd);
    unlink(tmpl);
    return true;
}

/* 释放字符串数组并清零 */
static void free_string_array(char ***arr, int *count) {
    if (!arr || !*arr || !count) return;
    for (int i = 0; i < *count; ++i) free((*arr)[i]);
    free(*arr);
    *arr  = NULL;
    *count = 0;
}

/* 自动选择 tempdir：第一个 rw tmpfs 下的 .magic_mount，否则 fallback */
static const char *select_auto_tempdir(char buf[PATH_MAX]) {
    const char *tmp_list[] = {"/mnt/vendor", "/mnt", "/debug_ramdisk"};
    size_t n = sizeof(tmp_list) / sizeof(tmp_list[0]);

    for (size_t i = 0; i < n; ++i) {
        const char *base = tmp_list[i];
        if (!is_rw_tmpfs(base)) continue;
        if (path_join(base, ".magic_mount", buf, PATH_MAX) != 0) continue;

        LOGI("auto tempdir selected: %s (from %s)", buf, base);
        return buf;
    }

    LOGW("no rw tmpfs found in candidates, fallback to %s", DEFAULT_TEMP_DIR);
    return DEFAULT_TEMP_DIR;
}

/* 记录模块失败（去重） */
static void register_module_failure(const char *module_name) {
    if (!module_name) return;

    for (int i = 0; i < g_failed_modules_count; ++i) {
        if (strcmp(g_failed_modules[i], module_name) == 0)
            return;
    }

    char **arr = realloc(
        g_failed_modules,
        (size_t)(g_failed_modules_count + 1) * sizeof(char*)
    );
    if (!arr) return;

    g_failed_modules = arr;
    g_failed_modules[g_failed_modules_count] = strdup(module_name);
    if (!g_failed_modules[g_failed_modules_count]) return;

    g_failed_modules_count++;
}

/* 添加额外分区名，name 为单个 token（不含逗号） */
static void add_extra_part_token(const char *start, size_t len) {
    while (len > 0 && (start[0] == ' ' || start[0] == '\t')) { start++; len--; }
    while (len > 0 && (start[len-1] == ' ' || start[len-1] == '\t')) len--;

    if (len == 0) return;

    char *name = malloc(len + 1);
    if (!name) return;

    memcpy(name, start, len);
    name[len] = '\0';

    char **arr = realloc(
        g_extra_parts,
        (size_t)(g_extra_parts_count + 1) * sizeof(char*)
    );
    if (!arr) {
        free(name);
        return;
    }

    g_extra_parts = arr;
    g_extra_parts[g_extra_parts_count++] = name;
}

/*==============================================================================
 * SELinux xattr（通用接口）
 *============================================================================*/

static int lsetfilecon(const char *path, const char *con) {
#if defined(__linux__)
    if (!path || !con) {
        LOGD("lsetfilecon called with path=%p, con=%p (skip)",
             (void*)path, (void*)con);
        return 0;
    }

    LOGD("lsetfilecon(%s, \"%s\")", path, con);

    if (lsetxattr(path, SELINUX_XATTR, con, strlen(con), 0) < 0) {
        LOGW("setcon %s: %s", path, strerror(errno));
        return -1;
    }

    LOGD("lsetfilecon(%s) ok", path);
#else
    LOGD("lsetfilecon(%s, %s) skipped (no SELinux on this platform)",
         path ? path : "(null)", con ? con : "(null)");
    UNUSED(path);
    UNUSED(con);
#endif
    return 0;
}

static int lgetfilecon(const char *path, char **out) {
    *out = NULL;
#if defined(__linux__)
    if (!path) {
        LOGD("lgetfilecon called with NULL path");
        errno = EINVAL;
        return -1;
    }

    LOGD("lgetfilecon(%s)", path);

    ssize_t sz = lgetxattr(path, SELINUX_XATTR, NULL, 0);
    if (sz < 0) {
        LOGW("getcon %s: %s", path, strerror(errno));
        return -1;
    }

    char *buf = malloc((size_t)sz + 1);
    if (!buf) {
        errno = ENOMEM;
        return -1;
    }

    ssize_t r = lgetxattr(path, SELINUX_XATTR, buf, (size_t)sz);
    if (r < 0) {
        LOGW("getcon %s (read): %s", path, strerror(errno));
        free(buf);
        return -1;
    }
    buf[r] = '\0';
    *out = buf;

    LOGD("lgetfilecon(%s) -> \"%s\"", path, buf);
#else
    LOGD("lgetfilecon(%s) skipped (no SELinux on this platform)",
         path ? path : "(null)");
    UNUSED(path);
#endif
    return 0;
}

/*==============================================================================
 * Node 结构 & 模块扫描
 *============================================================================*/

typedef enum {
    NFT_REGULAR,
    NFT_DIRECTORY,
    NFT_SYMLINK,
    NFT_WHITEOUT
} NodeFileType;

typedef struct Node {
    char         *name;
    NodeFileType  type;
    struct Node **children;
    size_t        child_count;
    char         *module_path;   // 在模块中的完整路径
    char         *module_name;   // 模块名（目录名），例如 "foo"
    bool          replace;
    bool          skip;
    bool          done;
} Node;

static Node *node_new(const char *name, NodeFileType t) {
    Node *n = calloc(1, sizeof(Node));
    if (!n) return NULL;

    n->name = strdup(name ? name : "");
    n->type = t;
    return n;
}

static void node_free(Node *n) {
    if (!n) return;

    for (size_t i = 0; i < n->child_count; ++i)
        node_free(n->children[i]);

    free(n->children);
    free(n->name);
    free(n->module_path);
    free(n->module_name);
    free(n);
}

static NodeFileType node_type_from_stat(const struct stat *st) {
    if (S_ISCHR(st->st_mode) && st->st_rdev == 0) return NFT_WHITEOUT;
    if (S_ISREG(st->st_mode)) return NFT_REGULAR;
    if (S_ISDIR(st->st_mode)) return NFT_DIRECTORY;
    if (S_ISLNK(st->st_mode)) return NFT_SYMLINK;
    return NFT_WHITEOUT;
}

static bool dir_is_replace(const char *path) {
    char buf[8];
    ssize_t len = lgetxattr(path, REPLACE_DIR_XATTR, buf, sizeof(buf) - 1);
    if (len <= 0) return false;

    buf[len] = '\0';
    return (strcmp(buf, "y") == 0);
}

/* module_name 为模块名，例如 "foo" */
static Node *node_new_module(const char *name,
                             const char *path,
                             const char *module_name)
{
    struct stat st;
    if (lstat(path, &st) < 0) return NULL;

    if (!(S_ISCHR(st.st_mode) ||
          S_ISREG(st.st_mode) ||
          S_ISDIR(st.st_mode) ||
          S_ISLNK(st.st_mode)))
        return NULL;

    NodeFileType t = node_type_from_stat(&st);
    Node *n = node_new(name, t);
    if (!n) return NULL;

    n->module_path = strdup(path);
    if (module_name) n->module_name = strdup(module_name);
    n->replace = (t == NFT_DIRECTORY) && dir_is_replace(path);

    g_stats.nodes_total++;
    return n;
}

static int node_add_child(Node *parent, Node *child) {
    Node **arr = realloc(
        parent->children,
        (parent->child_count + 1) * sizeof(Node*)
    );
    if (!arr) {
        errno = ENOMEM;
        return -1;
    }

    parent->children = arr;
    parent->children[parent->child_count++] = child;
    return 0;
}

static Node *node_find_child(Node *parent, const char *name) {
    for (size_t i = 0; i < parent->child_count; ++i) {
        if (strcmp(parent->children[i]->name, name) == 0)
            return parent->children[i];
    }
    return NULL;
}

static Node *node_take_child(Node *parent, const char *name) {
    for (size_t i = 0; i < parent->child_count; ++i) {
        if (strcmp(parent->children[i]->name, name) == 0) {
            Node *n = parent->children[i];
            memmove(&parent->children[i],
                    &parent->children[i + 1],
                    (parent->child_count - i - 1) * sizeof(Node*));
            parent->child_count--;
            return n;
        }
    }
    return NULL;
}

static bool module_disabled(const char *mod_dir) {
    char buf[PATH_MAX];

    path_join(mod_dir, DISABLE_FILE_NAME, buf, sizeof(buf));
    if (path_exists(buf)) return true;

    path_join(mod_dir, REMOVE_FILE_NAME, buf, sizeof(buf));
    if (path_exists(buf)) return true;

    path_join(mod_dir, SKIP_MOUNT_FILE_NAME, buf, sizeof(buf));
    if (path_exists(buf)) return true;

    return false;
}

/* 递归收集模块文件，module_name 为模块名 */
static int node_collect(Node *self,
                        const char *dir,
                        const char *module_name,
                        bool *has_any)
{
    DIR *d = opendir(dir);
    if (!d) {
        LOGE("opendir %s: %s", dir, strerror(errno));
        return -1;
    }

    struct dirent *de;
    bool any = false;
    char path[PATH_MAX];

    while ((de = readdir(d))) {
        if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, ".."))
            continue;

        if (path_join(dir, de->d_name, path, sizeof(path)) != 0) {
            closedir(d);
            return -1;
        }

        Node *child = node_find_child(self, de->d_name);
        if (!child) {
            Node *n = node_new_module(de->d_name, path, module_name);
            if (n) {
                if (node_add_child(self, n) != 0) {
                    node_free(n);
                    closedir(d);
                    return -1;
                }
                child = n;
            }
        }

        if (child) {
            if (child->type == NFT_DIRECTORY) {
                bool sub = false;
                if (node_collect(child, path, module_name, &sub) != 0) {
                    closedir(d);
                    return -1;
                }
                if (sub || child->replace) any = true;
            } else {
                any = true;
            }
        }
    }

    closedir(d);
    *has_any = any;
    return 0;
}

static Node *collect_root(void) {
    const char *mdir = g_module_dir;
    Node *root   = node_new("",       NFT_DIRECTORY);
    Node *system = node_new("system", NFT_DIRECTORY);

    if (!root || !system) {
        node_free(root);
        node_free(system);
        return NULL;
    }

    DIR *d = opendir(mdir);
    if (!d) {
        LOGE("opendir %s: %s", mdir, strerror(errno));
        node_free(root);
        node_free(system);
        return NULL;
    }

    struct dirent *de;
    bool has_any = false;
    char mod[PATH_MAX];
    char mod_sys[PATH_MAX];

    while ((de = readdir(d))) {
        if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, ".."))
            continue;

        if (path_join(mdir, de->d_name, mod, sizeof(mod)) != 0) {
            closedir(d);
            node_free(root);
            node_free(system);
            return NULL;
        }

        struct stat st;
        if (stat(mod, &st) < 0 || !S_ISDIR(st.st_mode))
            continue;

        if (module_disabled(mod))
            continue;

        if (path_join(mod, "system", mod_sys, sizeof(mod_sys)) != 0) {
            closedir(d);
            node_free(root);
            node_free(system);
            return NULL;
        }

        if (!path_is_dir(mod_sys))
            continue;

        LOGD("collecting module %s", de->d_name);
        g_stats.modules_total++;

        bool sub = false;
        if (node_collect(system, mod_sys, de->d_name, &sub) != 0) {
            closedir(d);
            node_free(root);
            node_free(system);
            return NULL;
        }
        if (sub) has_any = true;
    }

    closedir(d);

    if (!has_any) {
        node_free(root);
        node_free(system);
        return NULL;
    }

    /* root 和 system 自身也计入节点数 */
    g_stats.nodes_total += 2;

    /*
     * 内置分区：
     *   vendor, system_ext, product, odm
     * 其中前三个要求 /system/<name> 是 symlink。
     * 额外分区（-p）行为类似 odm：只检查 /<name> 是否为目录。
     */
    struct {
        const char *name;
        bool        need_symlink;
    } builtin_parts[] = {
        { "vendor",     true  },
        { "system_ext", true  },
        { "product",    true  },
        { "odm",        false },
    };

    char rp[PATH_MAX];
    char sp[PATH_MAX];

    // builtin 分区
    for (size_t i = 0; i < sizeof(builtin_parts)/sizeof(builtin_parts[0]); ++i) {
        if (path_join("/",       builtin_parts[i].name, rp, sizeof(rp)) != 0 ||
            path_join("/system", builtin_parts[i].name, sp, sizeof(sp)) != 0) {
            node_free(root);
            node_free(system);
            return NULL;
        }

        if (!path_is_dir(rp))
            continue;

        if (builtin_parts[i].need_symlink && !path_is_symlink(sp))
            continue;

        Node *child = node_take_child(system, builtin_parts[i].name);
        if (child && node_add_child(root, child) != 0) {
            node_free(child);
            node_free(root);
            node_free(system);
            return NULL;
        }
    }

    // 额外分区（行为类似 odm）
    for (int i = 0; i < g_extra_parts_count; ++i) {
        const char *name = g_extra_parts[i];

        if (path_join("/", name, rp, sizeof(rp)) != 0) {
            node_free(root);
            node_free(system);
            return NULL;
        }

        if (!path_is_dir(rp))
            continue;

        Node *child = node_take_child(system, name);
        if (child && node_add_child(root, child) != 0) {
            node_free(child);
            node_free(root);
            node_free(system);
            return NULL;
        }
    }

    if (node_add_child(root, system) != 0) {
        node_free(root);
        node_free(system);
        return NULL;
    }

    return root;
}

/*==============================================================================
 * magic mount 挂载逻辑
 *============================================================================*/

static int clone_symlink(const char *src, const char *dst) {
    char target[PATH_MAX];

    ssize_t len = readlink(src, target, sizeof(target) - 1);
    if (len < 0) {
        LOGE("readlink %s: %s", src, strerror(errno));
        return -1;
    }

    target[len] = '\0';

    if (symlink(target, dst) < 0) {
        LOGE("symlink %s->%s: %s", dst, target, strerror(errno));
        return -1;
    }

    char *con = NULL;
    if (lgetfilecon(src, &con) == 0 && con) {
        lsetfilecon(dst, con);
        free(con);
    }

    LOGD("clone symlink %s -> %s (%s)", src, dst, target);
    return 0;
}

static int mirror(const char *path, const char *work, const char *name);

static int do_magic(const char *base,
                    const char *wbase,
                    Node *node,
                    bool has_tmpfs)
{
    char path[PATH_MAX];
    char wpath[PATH_MAX];

    if (path_join(base,  node->name, path,  sizeof(path))  != 0 ||
        path_join(wbase, node->name, wpath, sizeof(wpath)) != 0)
        return -1;

    switch (node->type) {
    case NFT_REGULAR: {
        const char *target = has_tmpfs ? wpath : path;

        if (has_tmpfs) {
            if (mkdir_p(wbase) != 0) return -1;

            int fd = open(wpath, O_CREAT | O_WRONLY, 0644);
            if (fd < 0) {
                LOGE("create %s: %s", wpath, strerror(errno));
                return -1;
            }
            close(fd);
        }

        if (!node->module_path) {
            LOGE("no module file for %s", path);
            errno = EINVAL;
            return -1;
        }

        LOGD("bind %s -> %s", node->module_path, target);

        if (mount(node->module_path, target, NULL, MS_BIND, NULL) < 0) {
            LOGE("bind %s->%s: %s",
                 node->module_path, target, strerror(errno));
            return -1;
        }

        (void)mount(NULL, target, NULL,
                    MS_REMOUNT | MS_BIND | MS_RDONLY, NULL);

        g_stats.nodes_mounted++;
        return 0;
    }

    case NFT_SYMLINK: {
        if (!node->module_path) {
            LOGE("no module symlink for %s", path);
            errno = EINVAL;
            return -1;
        }

        if (clone_symlink(node->module_path, wpath) != 0)
            return -1;

        g_stats.nodes_mounted++;
        return 0;
    }

    case NFT_WHITEOUT:
        LOGD("whiteout %s", path);
        g_stats.nodes_whiteout++;
        return 0;

    case NFT_DIRECTORY: {
        bool create_tmp = (!has_tmpfs &&
                           node->replace &&
                           node->module_path);

        if (!has_tmpfs && !create_tmp) {
            for (size_t i = 0; i < node->child_count; ++i) {
                Node *c = node->children[i];
                char rp[PATH_MAX];

                if (path_join(path, c->name, rp, sizeof(rp)) != 0)
                    return -1;

                bool need = false;

                if (c->type == NFT_SYMLINK) {
                    need = true;
                } else if (c->type == NFT_WHITEOUT) {
                    need = path_exists(rp);
                } else {
                    struct stat st;
                    if (lstat(rp, &st) == 0) {
                        NodeFileType rt = node_type_from_stat(&st);
                        if (rt != c->type || rt == NFT_SYMLINK)
                            need = true;
                    } else {
                        need = true;
                    }
                }

                if (need) {
                    if (!node->module_path) {
                        LOGE("cannot create tmpfs on %s (%s)",
                             path, c->name);
                        c->skip = true;
                        g_stats.nodes_skipped++;
                        continue;
                    }
                    create_tmp = true;
                    break;
                }
            }
        }

        bool now_tmp = has_tmpfs || create_tmp;

        if (now_tmp) {
            if (mkdir_p(wpath) != 0) return -1;

            struct stat st;
            const char *meta_path = NULL;

            if (stat(path, &st) == 0) {
                meta_path = path;
            } else if (node->module_path &&
                       stat(node->module_path, &st) == 0) {
                meta_path = node->module_path;
            } else {
                LOGE("no dir meta for %s", path);
                errno = ENOENT;
                return -1;
            }

            chmod(wpath, st.st_mode & 07777);
            chown(wpath, st.st_uid, st.st_gid);

            char *con = NULL;
            if (lgetfilecon(meta_path, &con) == 0 && con) {
                lsetfilecon(wpath, con);
                free(con);
            }
        }

        if (create_tmp) {
            if (mount(wpath, wpath, NULL, MS_BIND, NULL) < 0) {
                LOGE("bind self %s: %s", wpath, strerror(errno));
                return -1;
            }
        }

        if (path_exists(path) && !node->replace) {
            DIR *d = opendir(path);
            if (!d) {
                LOGE("opendir %s: %s", path, strerror(errno));
                if (now_tmp) return -1;
            } else {
                struct dirent *de;
                while ((de = readdir(d))) {
                    if (!strcmp(de->d_name, ".") ||
                        !strcmp(de->d_name, "..")) {
                        continue;
                    }

                    Node *c = node_find_child(node, de->d_name);
                    int r = 0;

                    if (c) {
                        if (c->skip) {
                            c->done = true;
                            continue;
                        }
                        c->done = true;
                        r = do_magic(path, wpath, c, now_tmp);
                    } else if (now_tmp) {
                        r = mirror(path, wpath, de->d_name);
                    }

                    if (r != 0) {
                        const char *mn = NULL;

                        if (c && c->module_name)
                            mn = c->module_name;
                        else if (node->module_name)
                            mn = node->module_name;

                        if (mn) {
                            LOGE("child %s/%s failed (module: %s)",
                                 path,
                                 c ? c->name : de->d_name,
                                 mn);
                            register_module_failure(mn);
                        } else {
                            LOGE("child %s/%s failed (no module_name)",
                                 path,
                                 c ? c->name : de->d_name);
                        }

                        g_stats.nodes_fail++;

                        if (now_tmp) {
                            closedir(d);
                            return -1;
                        }
                    }
                }
                closedir(d);
            }
        }

        for (size_t i = 0; i < node->child_count; ++i) {
            Node *c = node->children[i];
            if (c->skip || c->done) continue;

            int r = do_magic(path, wpath, c, now_tmp);
            if (r != 0) {
                const char *mn = c->module_name ?
                                 c->module_name :
                                 node->module_name;

                if (mn) {
                    LOGE("child %s/%s failed (module: %s)",
                         path, c->name, mn);
                    register_module_failure(mn);
                } else {
                    LOGE("child %s/%s failed (no module_name)",
                         path, c->name);
                }

                g_stats.nodes_fail++;
                if (now_tmp) return -1;
            }
        }

        if (create_tmp) {
            (void)mount(NULL, wpath, NULL,
                        MS_REMOUNT | MS_BIND | MS_RDONLY, NULL);

            if (mount(wpath, path, NULL, MS_MOVE, NULL) < 0) {
                LOGE("move %s->%s failed: %s",
                     wpath, path, strerror(errno));
                if (node->module_name)
                    register_module_failure(node->module_name);
                return -1;
            }

            LOGI("move mountpoint success: %s -> %s", wpath, path);
            (void)mount(NULL, path, NULL, MS_REC | MS_PRIVATE, NULL);
        }

        g_stats.nodes_mounted++;
        return 0;
    }
    }

    return 0;
}

static int mirror(const char *path, const char *work, const char *name) {
    char src[PATH_MAX];
    char dst[PATH_MAX];

    if (path_join(path, name, src, sizeof(src)) != 0 ||
        path_join(work, name, dst, sizeof(dst)) != 0)
        return -1;

    struct stat st;
    if (lstat(src, &st) < 0) {
        LOGW("lstat %s: %s", src, strerror(errno));
        return 0; // 忽略
    }

    if (S_ISREG(st.st_mode)) {
        int fd = open(dst, O_CREAT | O_WRONLY, st.st_mode & 07777);
        if (fd < 0) {
            LOGE("create %s: %s", dst, strerror(errno));
            return -1;
        }
        close(fd);

        if (mount(src, dst, NULL, MS_BIND, NULL) < 0) {
            LOGE("bind %s->%s: %s", src, dst, strerror(errno));
            return -1;
        }
    } else if (S_ISDIR(st.st_mode)) {
        if (mkdir(dst, st.st_mode & 07777) < 0 && errno != EEXIST) {
            LOGE("mkdir %s: %s", dst, strerror(errno));
            return -1;
        }

        chmod(dst, st.st_mode & 07777);
        chown(dst, st.st_uid, st.st_gid);

        char *con = NULL;
        if (lgetfilecon(src, &con) == 0 && con) {
            lsetfilecon(dst, con);
            free(con);
        }

        DIR *d = opendir(src);
        if (!d) {
            LOGE("opendir %s: %s", src, strerror(errno));
            return -1;
        }

        struct dirent *de;
        while ((de = readdir(d))) {
            if (!strcmp(de->d_name, ".") ||
                !strcmp(de->d_name, "..")) {
                continue;
            }
            if (mirror(src, dst, de->d_name) != 0) {
                closedir(d);
                return -1;
            }
        }
        closedir(d);
    } else if (S_ISLNK(st.st_mode)) {
        if (clone_symlink(src, dst) != 0)
            return -1;
    }

    return 0;
}

static int magic_mount(const char *tmp_root) {
    Node *root = collect_root();
    if (!root) {
        LOGI("no modules, magic_mount skipped");
        return 0;
    }

    char tmp_dir[PATH_MAX];
    if (path_join(tmp_root, "workdir", tmp_dir, sizeof(tmp_dir)) != 0) {
        node_free(root);
        return -1;
    }

    if (mkdir_p(tmp_dir) != 0) {
        node_free(root);
        return -1;
    }

    LOGI("starting magic_mount core logic: tmpfs_source=%s tmp_dir=%s",
         g_mount_source, tmp_dir);

    if (mount(g_mount_source, tmp_dir, "tmpfs", 0, "") < 0) {
        LOGE("mount tmpfs %s: %s", tmp_dir, strerror(errno));
        node_free(root);
        return -1;
    }

    (void)mount(NULL, tmp_dir, NULL, MS_REC | MS_PRIVATE, NULL);

    int rc = do_magic("/", tmp_dir, root, false);
    if (rc != 0)
        g_stats.nodes_fail++;

    if (umount2(tmp_dir, MNT_DETACH) < 0)
        LOGE("umount %s: %s", tmp_dir, strerror(errno));

    (void)rmdir(tmp_dir);

    node_free(root);
    return rc;
}

/*==============================================================================
 * 进程环境 & CLI
 *============================================================================*/

static void usage(const char *prog) {
    fprintf(stderr,
            "Magic Mount Version: %s\n"
            "Usage: %s [options]\n"
            "  -m DIR     module dir (default: %s)\n"
            "  -t DIR     temp dir   (default: auto rw tmpfs + \".magic_mount\")\n"
            "  -s SRC     mount src  (default: %s)\n"
            "  -p LIST    extra partitions, comma-separated (e.g. mi_ext,my_stock)\n"
            "  -l FILE    log file   (default: stderr, '-'=stdout)\n"
            "  -v N       verbose    (0=ERROR,1=WARN,2=INFO,3=DEBUG)\n"
            "  -h         help\n",
            MAGIC_MOUNT_VERSION,
            prog,
            DEFAULT_MODULE_DIR,
            DEFAULT_MOUNT_SOURCE);
}

static int enter_pid1_ns(void) {
    int fd = open("/proc/1/ns/mnt", O_RDONLY);
    if (fd < 0) {
        LOGE("open /proc/1/ns/mnt: %s", strerror(errno));
        return -1;
    }

    if (setns(fd, 0) < 0) {
        LOGE("setns: %s", strerror(errno));
        close(fd);
        return -1;
    }

    close(fd);
    LOGI("entered pid1 mnt ns");
    return 0;
}

int main(int argc, char **argv) {
    const char *tmp_dir  = NULL;
    const char *log_path = NULL;
    char        auto_tmp[PATH_MAX] = {0};

    for (int i = 1; i < argc; ++i) {
        const char *arg = argv[i];

        if ((strcmp(arg, "-m") == 0 || strcmp(arg, "--module-dir") == 0) &&
            i + 1 < argc) {
            g_module_dir = argv[++i];

        } else if ((strcmp(arg, "-t") == 0 || strcmp(arg, "--temp-dir") == 0) &&
                   i + 1 < argc) {
            tmp_dir = argv[++i];

        } else if ((strcmp(arg, "-s") == 0 ||
                    strcmp(arg, "--mount-source") == 0) &&
                   i + 1 < argc) {
            g_mount_source = argv[++i];

        } else if ((strcmp(arg, "-l") == 0 ||
                    strcmp(arg, "--log-file") == 0) &&
                   i + 1 < argc) {
            log_path = argv[++i];

        } else if ((strcmp(arg, "-v") == 0 ||
                    strcmp(arg, "--verbose") == 0) &&
                   i + 1 < argc) {
            g_log_level = atoi(argv[++i]);
            if (g_log_level < 0) g_log_level = 0;
            if (g_log_level > 3) g_log_level = 3;

        } else if ((strcmp(arg, "-p") == 0 ||
                    strcmp(arg, "--partitions") == 0) &&
                   i + 1 < argc) {
            const char *list = argv[++i];
            const char *p = list;
            while (*p) {
                const char *start = p;
                while (*p && *p != ',') p++;
                size_t len = (size_t)(p - start);
                add_extra_part_token(start, len);
                if (*p == ',') p++;
            }

        } else if (!strcmp(arg, "-h") || !strcmp(arg, "--help")) {
            usage(argv[0]);
            return 0;

        } else {
            fprintf(stderr, "Unknown arg: %s\n", arg);
            usage(argv[0]);
            return 1;
        }
    }

    if (log_path) {
        if (!strcmp(log_path, "-")) {
            g_log_file = stdout;
        } else {
            g_log_file = fopen(log_path, "a");
            if (!g_log_file) {
                fprintf(stderr, "open log %s: %s\n",
                        log_path, strerror(errno));
                return 1;
            }
        }
    }

    if (!tmp_dir) {
        tmp_dir = select_auto_tempdir(auto_tmp);
    }

    if (geteuid() != 0) {
        LOGE("must run as root (euid=%d)", (int)geteuid());
        if (g_log_file && g_log_file != stdout && g_log_file != stderr)
            fclose(g_log_file);
        free_string_array(&g_extra_parts, &g_extra_parts_count);
        return 1;
    }

    if (enter_pid1_ns() != 0) {
        if (g_log_file && g_log_file != stdout && g_log_file != stderr)
            fclose(g_log_file);
        free_string_array(&g_extra_parts, &g_extra_parts_count);
        return 1;
    }

    int rc = 0;

        LOGI("starting magic_mount process: module_dir=%s temp_dir=%s "
             "mount_source=%s log_level=%d",
             g_module_dir, tmp_dir, g_mount_source, g_log_level);

        rc = magic_mount(tmp_dir);

        if (rc == 0) {
            LOGI("magic_mount completed successfully");
        } else {
            LOGE("magic_mount failed with rc=%d "
                 "(check previous logs for details)", rc);
        }

        LOGI("magic_mount summary: modules=%d nodes_total=%d mounted=%d "
             "skipped=%d whiteouts=%d failures=%d",
             g_stats.modules_total,
             g_stats.nodes_total,
             g_stats.nodes_mounted,
             g_stats.nodes_skipped,
             g_stats.nodes_whiteout,
             g_stats.nodes_fail);

        if (g_failed_modules_count > 0) {
            LOGW("modules with failures (%d):", g_failed_modules_count);
            for (int i = 0; i < g_failed_modules_count; ++i) {
                LOGW("  failed module: %s", g_failed_modules[i]);
            }
        }


    if (g_log_file && g_log_file != stdout && g_log_file != stderr)
        fclose(g_log_file);

    free_string_array(&g_failed_modules, &g_failed_modules_count);
    free_string_array(&g_extra_parts, &g_extra_parts_count);

    return rc == 0 ? 0 : 1;
}