import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.regex.Pattern;

/**
 * 树表 b_depth / b_path 核对与修复。
 *
 * 背景：模块管理 / 菜单管理的拖拽排序曾把根节点 b_path 的前导 / 抹掉
 * （`/base/` 被写成 `base/`），并把整棵树按错误规则重新落库。
 * b_parent_id 是权威关系，b_depth / b_path 是派生字段（见《FMS新系统核心表结构设计》1.7），
 * 因此受损数据可以按 b_parent_id 完整重建，本工具就是做这件事。
 *
 * 行为：
 * - 默认只读报告（不写库）；加 --apply 才在单个事务内重建，失败整体回滚。
 * - 只处理 b_depth / b_path 两列，b_parent_id 与其余字段一律不动。
 * - 成环的节点无法派生路径，只报告不修（父子关系是数据问题，应由人工先修）。
 *
 * 用法（在 fms-api 目录下运行）：
 *   java -cp "tools/migration/mssql-jdbc-13.4.0.jre11.jar" tools/migration/TreePathRepair.java
 *   java -cp "tools/migration/mssql-jdbc-13.4.0.jre11.jar" tools/migration/TreePathRepair.java --apply
 *   java -cp "tools/migration/mssql-jdbc-13.4.0.jre11.jar" tools/migration/TreePathRepair.java \
 *        --tables s_module,s_menu,b_dept,b_othercompany_category
 */
public final class TreePathRepair {

    /** 允许操作的表（树结构规范里的四张树表） */
    private static final Set<String> ALLOWED_TABLES = new LinkedHashSet<>(List.of(
            "s_module",
            "s_menu",
            "b_dept",
            "b_othercompany_category"
    ));

    private static final Pattern IDENTIFIER = Pattern.compile("[A-Za-z_][A-Za-z0-9_]*");
    private static final int PATH_LIMIT = 1000;
    private static final int SAMPLE_LIMIT = 30;

    public static void main(String[] args) throws Exception {
        boolean apply = false;
        List<String> tables = List.of("s_module", "s_menu");
        String configPath = "config/dbconfigs/G3HD.properties";

        for (int i = 0; i < args.length; i++) {
            String arg = args[i];
            if ("--apply".equalsIgnoreCase(arg)) {
                apply = true;
            } else if ("--dry-run".equalsIgnoreCase(arg)) {
                apply = false;
            } else if ("--tables".equalsIgnoreCase(arg) && i + 1 < args.length) {
                tables = List.of(args[++i].split(","));
            } else if ("--config".equalsIgnoreCase(arg) && i + 1 < args.length) {
                configPath = args[++i];
            } else {
                System.out.println("未知参数: " + arg);
                printUsage();
                return;
            }
        }

        List<String> normalizedTables = new ArrayList<>();
        for (String table : tables) {
            String name = table.trim();
            if (!normalizedTables.contains(name)) {
                normalizedTables.add(name);
            }
        }
        for (String table : normalizedTables) {
            if (!IDENTIFIER.matcher(table).matches() || !ALLOWED_TABLES.contains(table)) {
                throw new IllegalArgumentException(
                        "不允许的表: " + table + "（可选: " + String.join(", ", ALLOWED_TABLES) + "）"
                );
            }
        }

        Path apiRoot = Path.of("").toAbsolutePath().normalize();
        Path propertiesFile = apiRoot.resolve(configPath).normalize();
        Properties properties = new Properties();
        try (InputStream input = Files.newInputStream(propertiesFile)) {
            properties.load(input);
        }

        System.out.println(apply ? "模式: 修复（会写库）" : "模式: 只读报告（不写库，加 --apply 才修复）");
        System.out.println("配置文件: " + propertiesFile);

        try (Connection connection = DriverManager.getConnection(
                properties.getProperty("url"),
                properties.getProperty("username"),
                properties.getProperty("password")
        )) {
            System.out.println("目标库: " + connection.getCatalog());
            System.out.println();

            int totalChanged = 0;
            int totalBlocked = 0;
            for (String table : normalizedTables) {
                int[] result = repairTable(connection, table, apply);
                totalChanged += result[0];
                totalBlocked += result[1];
                System.out.println();
            }

            if (apply) {
                System.out.println("=== 修复完成：共更新 " + totalChanged + " 行，跳过 " + totalBlocked + " 行 ===");
            } else {
                System.out.println("=== 只读报告：待更新 " + totalChanged + " 行，跳过 " + totalBlocked + " 行 ===");
                if (totalChanged > 0) {
                    System.out.println("确认无误后加 --apply 执行修复。");
                }
            }
        }
    }

    /**
     * @return {待更新行数, 因成环/超长而跳过的行数}
     */
    private static int[] repairTable(Connection connection, String table, boolean apply) throws Exception {
        Map<String, Node> nodes = loadNodes(connection, table);
        Set<String> onCycle = findCycleNodes(nodes);

        Map<String, Position> expected = new LinkedHashMap<>();
        Set<String> blocked = new LinkedHashSet<>();
        Set<String> orphan = new LinkedHashSet<>();
        Set<String> tooLong = new LinkedHashSet<>();
        for (String id : nodes.keySet()) {
            resolve(id, nodes, expected, onCycle, blocked, orphan, tooLong);
        }

        List<Change> changes = new ArrayList<>();
        int depthMismatch = 0;
        int pathMismatch = 0;
        int missingLeadingSlash = 0;
        for (Map.Entry<String, Node> entry : nodes.entrySet()) {
            Position position = expected.get(entry.getKey());
            if (position == null) {
                continue;
            }
            Node node = entry.getValue();
            boolean depthDiffers = node.depth() != position.depth();
            boolean pathDiffers = !position.path().equals(node.path());
            if (!depthDiffers && !pathDiffers) {
                continue;
            }
            if (depthDiffers) {
                depthMismatch++;
            }
            if (pathDiffers) {
                pathMismatch++;
                // 本工具针对的典型症状：路径只是丢了前导 /
                if (position.path().equals("/" + node.path())) {
                    missingLeadingSlash++;
                }
            }
            changes.add(new Change(node, position));
        }

        System.out.println("=== " + table + "（" + nodes.size() + " 行）===");
        System.out.println("  成环节点（父子关系问题，本工具不修）: " + onCycle.size()
                + (onCycle.isEmpty() ? "" : " → " + join(limit(onCycle))));
        if (!blocked.isEmpty()) {
            System.out.println("  因父级成环/超长而无法派生: " + blocked.size() + " → " + join(limit(blocked)));
        }
        if (!orphan.isEmpty()) {
            System.out.println("  b_parent_id 指向不存在的节点（按根处理）: " + orphan.size()
                    + " → " + join(limit(orphan)));
        }
        if (!tooLong.isEmpty()) {
            System.out.println("  派生路径超过 " + PATH_LIMIT + " 字符（跳过）: " + tooLong.size()
                    + " → " + join(limit(tooLong)));
        }
        System.out.println("  b_path 不一致: " + pathMismatch + " 行（其中「只缺前导 /」: " + missingLeadingSlash + " 行）");
        System.out.println("  b_depth 不一致: " + depthMismatch + " 行");
        System.out.println("  待更新合计: " + changes.size() + " 行");

        if (changes.isEmpty()) {
            System.out.println("  无需修复。");
            return new int[]{0, blocked.size()};
        }

        System.out.println("  变更样例:");
        for (int i = 0; i < Math.min(SAMPLE_LIMIT, changes.size()); i++) {
            Change change = changes.get(i);
            System.out.printf("    %-28s depth %d→%d   path '%s' → '%s'%n",
                    change.node().id(),
                    change.node().depth(),
                    change.position().depth(),
                    change.node().path(),
                    change.position().path());
        }
        if (changes.size() > SAMPLE_LIMIT) {
            System.out.println("    ... 其余 " + (changes.size() - SAMPLE_LIMIT) + " 行略");
        }

        if (!apply) {
            return new int[]{changes.size(), blocked.size()};
        }

        String updateSql = "UPDATE dbo." + table
                + " SET b_depth = ?, b_path = ? WHERE b_id = ?";
        boolean originalAutoCommit = connection.getAutoCommit();
        connection.setAutoCommit(false);
        try (PreparedStatement statement = connection.prepareStatement(updateSql)) {
            for (Change change : changes) {
                statement.setInt(1, change.position().depth());
                statement.setString(2, change.position().path());
                statement.setString(3, change.node().id());
                statement.addBatch();
            }
            int[] affected = statement.executeBatch();
            for (int count : affected) {
                if (count != 1) {
                    throw new IllegalStateException("更新行数异常: " + count);
                }
            }
            connection.commit();
            System.out.println("  已提交 " + changes.size() + " 行。");
        } catch (Exception e) {
            connection.rollback();
            throw new IllegalStateException(table + " 修复失败，已回滚: " + e.getMessage(), e);
        } finally {
            if (originalAutoCommit) {
                connection.setAutoCommit(true);
            }
        }
        return new int[]{changes.size(), blocked.size()};
    }

    private static Map<String, Node> loadNodes(Connection connection, String table) throws Exception {
        String sql = "SELECT b_id, b_parent_id, b_depth, b_path FROM dbo." + table;
        Map<String, Node> nodes = new LinkedHashMap<>();
        try (Statement statement = connection.createStatement();
             ResultSet resultSet = statement.executeQuery(sql)) {
            while (resultSet.next()) {
                String id = normalize(resultSet.getString("b_id"));
                if (id == null) {
                    throw new IllegalStateException(table + " 存在 b_id 为空的行");
                }
                int depth = resultSet.getInt("b_depth");
                String path = resultSet.getString("b_path");
                nodes.put(id, new Node(
                        id,
                        normalize(resultSet.getString("b_parent_id")),
                        depth,
                        path == null ? "" : path
                ));
            }
        }
        return nodes;
    }

    /** 找出所有真正位于环上的节点（沿 b_parent_id 上溯，出现重复即为环） */
    private static Set<String> findCycleNodes(Map<String, Node> nodes) {
        Set<String> onCycle = new LinkedHashSet<>();
        for (String start : nodes.keySet()) {
            Map<String, Integer> seen = new LinkedHashMap<>();
            String current = start;
            while (current != null && nodes.containsKey(current)) {
                Integer previous = seen.get(current);
                if (previous != null) {
                    List<String> chain = new ArrayList<>(seen.keySet());
                    for (int i = previous; i < chain.size(); i++) {
                        onCycle.add(chain.get(i));
                    }
                    break;
                }
                seen.put(current, seen.size());
                current = nodes.get(current).parentId();
            }
        }
        return onCycle;
    }

    /** 自底向上派生 b_depth / b_path；父级成环或路径超长时返回 null 并记入 blocked */
    private static Position resolve(
            String id,
            Map<String, Node> nodes,
            Map<String, Position> cache,
            Set<String> onCycle,
            Set<String> blocked,
            Set<String> orphan,
            Set<String> tooLong
    ) {
        if (id == null || !nodes.containsKey(id)) {
            return null;
        }
        Position cached = cache.get(id);
        if (cached != null) {
            return cached;
        }
        if (onCycle.contains(id)) {
            blocked.add(id);
            return null;
        }

        Node node = nodes.get(id);
        int depth;
        String path;
        if (node.parentId() == null) {
            depth = 0;
            path = "/" + id + "/";
        } else {
            Position parent = resolve(node.parentId(), nodes, cache, onCycle, blocked, orphan, tooLong);
            if (parent == null) {
                if (nodes.containsKey(node.parentId())) {
                    // 父级在环上 / 被阻断，本节点同样无法派生
                    blocked.add(id);
                    return null;
                }
                // 父级不存在：与前端 buildTree 一致，提升为根
                orphan.add(id);
                depth = 0;
                path = "/" + id + "/";
            } else {
                depth = parent.depth() + 1;
                path = parent.path() + id + "/";
            }
        }

        if (path.length() > PATH_LIMIT) {
            tooLong.add(id);
            blocked.add(id);
            return null;
        }
        Position position = new Position(depth, path);
        cache.put(id, position);
        return position;
    }

    private static String normalize(String value) {
        if (value == null) {
            return null;
        }
        String trimmed = value.trim();
        return trimmed.isEmpty() ? null : trimmed;
    }

    private static List<String> limit(Set<String> values) {
        return values.stream().limit(SAMPLE_LIMIT).toList();
    }

    private static String join(List<String> values) {
        return String.join(", ", values);
    }

    private static void printUsage() {
        System.out.println("用法: TreePathRepair [--dry-run | --apply] [--tables s_module,s_menu,...] [--config <properties>]");
        System.out.println("  默认（不带参数）只读报告，不写库；--apply 才在单事务内重建 b_depth / b_path。");
        System.out.println("  可选表: " + String.join(", ", ALLOWED_TABLES));
        System.out.println("  --config 默认 config/dbconfigs/G3HD.properties（多机构时指向目标机构的配置）。");
    }

    private record Node(String id, String parentId, int depth, String path) {
    }

    private record Position(int depth, String path) {
    }

    private record Change(Node node, Position position) {
    }
}