#!/bin/bash
# run_robust.sh — 全量运行 210 个 OpenFOAM case（3 case types x 70 trajs）
#
# 用法: nohup bash /home/alanz/openfoam-workspace/run_robust.sh > /home/alanz/openfoam-workspace/output/run_all.log 2>&1 &
#
# 配置:
#   N_PARALLEL=3   — 并行运行 case 数
#   N_PROCS=4      — 每个 case 的 MPI 进程数（匹配 decomposeParDict numberOfSubdomains 4）
#   总计: 3 x 4 = 12 核（16 核机器留 4 核给系统）
#
# 流程:
#   1. 清理旧仿真数据（保留 0/ 初始条件）
#   2. 按 case type 顺序运行: dam_break → rising_bubble → droplet_impact
#   3. 每类内部并行（N_PARALLEL 路）
#   4. 记录统计和失败列表

set -o pipefail

WORKSPACE="/home/alanz/openfoam-workspace"
OUTPUT="$WORKSPACE/output/data"
SCRIPTS="$WORKSPACE/scripts"
N_PARALLEL=3
N_PROCS=4

# OpenFOAM 环境（如未加载）
if [ -z "$FOAM_ETC" ]; then
    export WM_PROJECT=OpenFOAM
    export WM_PROJECT_VERSION=v1906
    export WM_PROJECT_DIR=/usr/share/openfoam
    export FOAM_ETC=/usr/share/openfoam/etc
    export FOAM_APPBIN=/usr/bin
    export FOAM_LIBBIN=/usr/lib
    export PATH=$FOAM_APPBIN:$PATH
    export LD_LIBRARY_PATH=$FOAM_LIBBIN:$LD_LIBRARY_PATH
fi

# FPE 禁用库路径（仅用于 interFoam，不全局设置避免影响其他命令）
FPE_LIB="$SCRIPTS/lib_disable_fpe.so"

echo "============================================================"
echo "  OpenFOAM 全量运行 — run_robust.sh"
echo "============================================================"
echo "  输出目录: $OUTPUT"
echo "  并行数: $N_PARALLEL"
echo "  每 case MPI 进程: $N_PROCS (匹配 decomposeParDict)"
echo "  总核数: $((N_PARALLEL * N_PROCS)) / $(nproc)"
echo "  开始时间: $(date)"
echo "============================================================"

TOTAL_SUCCESS=0
TOTAL_FAILED=0
GLOBAL_START=$(date +%s)

for CASE_TYPE in dam_break rising_bubble droplet_impact; do
    CASES_DIR="$OUTPUT/$CASE_TYPE"
    LOG_DIR="$CASES_DIR/batch_logs"

    if [ ! -d "$CASES_DIR" ]; then
        echo ""
        echo "WARNING: $CASES_DIR 不存在，跳过"
        continue
    fi

    echo ""
    echo "============================================================"
    echo "  开始运行: $CASE_TYPE"
    echo "============================================================"

    # 发现 case 目录
    CASE_DIRS=()
    for d in "$CASES_DIR"/t[0-9]*; do
        [ -d "$d" ] && [ -f "$d/Allrun" ] && CASE_DIRS+=("$d")
    done
    TOTAL=${#CASE_DIRS[@]}

    if [ "$TOTAL" -eq 0 ]; then
        echo "WARNING: $CASE_TYPE 无 case 目录（含 Allrun），跳过"
        continue
    fi

    echo "  Case 数: $TOTAL"
    echo "  并行数: $N_PARALLEL"
    echo "  每 case MPI: $N_PROCS"

    # 清理旧仿真数据（保留 0/ 初始条件）
    CLEANED=0
    for case_dir in "$CASES_DIR"/t[0-9]*; do
        [ -d "$case_dir" ] || continue
        rm -f "$case_dir"/log.*
        rm -rf "$case_dir"/processor*
        rm -f "$case_dir"/done.marker
        # 删除时间步目录（保留 0/）
        for ts_dir in "$case_dir"/[0-9]*; do
            ts_name=$(basename "$ts_dir")
            [ "$ts_name" != "0" ] && rm -rf "$ts_dir"
        done 2>/dev/null
        CLEANED=$((CLEANED + 1))
    done
    echo "  已清理 $CLEANED 个 case 的旧仿真数据"

    mkdir -p "$LOG_DIR"

    TYPE_SUCCESS=0
    TYPE_FAILED=0
    TYPE_START=$(date +%s)

    # 追踪后台进程
    RUN_PIDS=()
    RUN_CASES=()

    run_case() {
        local case_dir="$1"
        local case_name
        case_name=$(basename "$case_dir")
        local log_file="$LOG_DIR/${case_name}.log"

        echo "[$(date +%H:%M:%S)] 启动: $case_name" >> "$log_file"
        cd "$case_dir"

        # blockMesh
        blockMesh >> "$log_file" 2>&1
        if [ $? -ne 0 ]; then
            echo "ERROR: blockMesh failed" >> "$log_file"
            return 1
        fi

        # decomposePar（并行模式）
        if [ "$N_PROCS" -gt 1 ]; then
            decomposePar -force >> "$log_file" 2>&1
            if [ $? -ne 0 ]; then
                echo "ERROR: decomposePar failed" >> "$log_file"
                return 1
            fi

            # interFoam 并行（通过 wrapper 禁用 FPE 捕获）
            mpirun -np "$N_PROCS" env LD_PRELOAD="$FPE_LIB" interFoam -parallel >> "$log_file" 2>&1
            if [ $? -ne 0 ]; then
                echo "ERROR: interFoam failed" >> "$log_file"
                return 1
            fi

            # reconstructPar
            reconstructPar >> "$log_file" 2>&1
            if [ $? -ne 0 ]; then
                echo "WARNING: reconstructPar failed" >> "$log_file"
            fi
        else
            # interFoam 串行（通过 wrapper 禁用 FPE 捕获）
            LD_PRELOAD="$FPE_LIB" interFoam >> "$log_file" 2>&1
            if [ $? -ne 0 ]; then
                echo "ERROR: interFoam failed" >> "$log_file"
                return 1
            fi
        fi

        # 标记完成
        touch "$case_dir/done.marker"
        echo "[$(date +%H:%M:%S)] 完成: $case_name" >> "$log_file"
        return 0
    }

    reap_finished() {
        local active_pids=()
        local active_cases=()
        for j in "${!RUN_PIDS[@]}"; do
            local pid="${RUN_PIDS[$j]}"
            if ! kill -0 "$pid" 2>/dev/null; then
                wait "$pid"
                local exit_code=$?
                local finished_case="${RUN_CASES[$j]}"
                if [ "$exit_code" -eq 0 ]; then
                    echo "[$(date +%H:%M:%S)] 完成: $finished_case"
                    TYPE_SUCCESS=$((TYPE_SUCCESS + 1))
                else
                    echo "[$(date +%H:%M:%S)] FAILED: $finished_case (exit=$exit_code)"
                    TYPE_FAILED=$((TYPE_FAILED + 1))
                fi
            else
                active_pids+=("$pid")
                active_cases+=("${RUN_CASES[$j]}")
            fi
        done
        RUN_PIDS=("${active_pids[@]+"${active_pids[@]}"}")
        RUN_CASES=("${active_cases[@]+"${active_cases[@]}"}")
    }

    # 信号处理
    cleanup() {
        echo ""
        echo "收到终止信号，等待正在运行的 case 完成..."
        for pid in "${RUN_PIDS[@]+"${RUN_PIDS[@]}"}"; do
            wait "$pid" 2>/dev/null
        done
        echo "所有进程已结束"
        exit 0
    }
    trap cleanup SIGINT SIGTERM

    # 提交所有 case
    for i in "${!CASE_DIRS[@]}"; do
        case_dir="${CASE_DIRS[$i]}"
        case_name=$(basename "$case_dir")
        idx=$((i + 1))

        # 等待直到有空闲 slot
        while [ "${#RUN_PIDS[@]}" -ge "$N_PARALLEL" ]; do
            reap_finished
            [ "${#RUN_PIDS[@]}" -ge "$N_PARALLEL" ] && sleep 2
        done

        run_case "$case_dir" &
        bg_pid=$!
        RUN_PIDS+=("$bg_pid")
        RUN_CASES+=("$case_name")
        echo "[$(date +%H:%M:%S)] [$idx/$TOTAL] 已提交: $case_name (pid=$bg_pid)"
    done

    # 等待所有剩余进程
    echo ""
    echo "等待 $CASE_TYPE 所有 case 完成..."
    for j in "${!RUN_PIDS[@]}"; do
        pid="${RUN_PIDS[$j]}"
        wait "$pid"
        exit_code=$?
        finished_case="${RUN_CASES[$j]}"
        if [ "$exit_code" -eq 0 ]; then
            echo "[$(date +%H:%M:%S)] 完成: $finished_case"
            TYPE_SUCCESS=$((TYPE_SUCCESS + 1))
        else
            echo "[$(date +%H:%M:%S)] FAILED: $finished_case (exit=$exit_code)"
            TYPE_FAILED=$((TYPE_FAILED + 1))
        fi
    done

    TYPE_END=$(date +%s)
    TYPE_ELAPSED=$((TYPE_END - TYPE_START))
    TYPE_MINS=$((TYPE_ELAPSED / 60))

    echo ""
    echo "--- $CASE_TYPE 完成 ---"
    echo "  成功: $TYPE_SUCCESS / $TOTAL"
    echo "  失败: $TYPE_FAILED / $TOTAL"
    echo "  耗时: ${TYPE_MINS} 分钟"
    echo "  日志: $LOG_DIR"

    TOTAL_SUCCESS=$((TOTAL_SUCCESS + TYPE_SUCCESS))
    TOTAL_FAILED=$((TOTAL_FAILED + TYPE_FAILED))

    # 打印失败列表
    if [ "$TYPE_FAILED" -gt 0 ]; then
        echo "  失败 case:"
        for log in "$LOG_DIR"/*.log; do
            [ -f "$log" ] || continue
            cn=$(basename "$log" .log)
            if grep -q "^ERROR" "$log" 2>/dev/null; then
                echo "    $cn: $(grep '^ERROR' "$log" | head -1)"
            fi
        done
    fi
done

GLOBAL_END=$(date +%s)
GLOBAL_ELAPSED=$((GLOBAL_END - GLOBAL_START))
GLOBAL_MINS=$((GLOBAL_ELAPSED / 60))
GLOBAL_HOURS=$((GLOBAL_ELAPSED / 3600))

echo ""
echo "============================================================"
echo "  全量运行完成"
echo "============================================================"
echo "  总计成功: $TOTAL_SUCCESS / 210"
echo "  总计失败: $TOTAL_FAILED / 210"
echo "  总耗时: ${GLOBAL_MINS} 分钟 (~${GLOBAL_HOURS} 小时)"
echo "  结束时间: $(date)"
echo "============================================================"