┌─────────────┐     相同輸入資料     ┌─────────────┐
│   舊系統      │ ◄──────────────► │   新系統      │
│  (Baseline)  │                    │  (Target)    │
└──────┬───────┘                    └──────┬───────┘
       │                                    │
       ▼                                    ▼
  舊系統產出                           新系統產出
       │                                    │
       └──────────► 差異比對 ◄──────────────┘
                       │
                       ▼
                  差異報告與分析

/**
 * 錯誤示範：使用 double 計算金額
 */
public class BadExample {
    public static void main(String[] args) {
        double amount1 = 0.1 + 0.2;
        System.out.println(amount1); // 輸出：0.30000000000000004 ❌
    }
}

/**
 * 正確做法：使用 BigDecimal 計算金額
 */
import java.math.BigDecimal;
import java.math.RoundingMode;

public class GoodExample {
    public static void main(String[] args) {
        BigDecimal amount1 = new BigDecimal("0.1");
        BigDecimal amount2 = new BigDecimal("0.2");
        BigDecimal result = amount1.add(amount2);
        System.out.println(result); // 輸出：0.3 ✅
        
        // 利息計算範例：本金 × 年利率 ÷ 365
        BigDecimal principal = new BigDecimal("1000000");
        BigDecimal rate = new BigDecimal("0.025");
        BigDecimal dailyInterest = principal.multiply(rate)
            .divide(new BigDecimal("365"), 2, RoundingMode.HALF_UP);
        System.out.println("日利息：" + dailyInterest); // 68.49
    }
}

import java.math.BigDecimal;
import java.math.RoundingMode;

/**
 * 平行測試比對工具 - 金額比對邏輯
 */
public class AmountComparator {
    
    /** 容忍誤差：0.01 元 */
    private static final BigDecimal TOLERANCE = new BigDecimal("0.01");
    
    /**
     * 比對兩筆金額是否在容忍範圍內
     * @param oldAmount 舊系統金額
     * @param newAmount 新系統金額
     * @return 比對結果
     */
    public static CompareResult compareAmount(BigDecimal oldAmount, BigDecimal newAmount) {
        BigDecimal diff = oldAmount.subtract(newAmount).abs();
        
        if (diff.compareTo(BigDecimal.ZERO) == 0) {
            return new CompareResult("EXACT_MATCH", diff);
        } else if (diff.compareTo(TOLERANCE) <= 0) {
            return new CompareResult("WITHIN_TOLERANCE", diff);
        } else {
            return new CompareResult("MISMATCH", diff);
        }
    }
    
    /**
     * 比對結果紀錄
     */
    public record CompareResult(String status, BigDecimal difference) {}
}

-- ============================================
-- 筆數比對：確認新舊系統交易筆數一致
-- ============================================

-- 舊系統交易筆數
SELECT 
    TXN_DATE,
    TXN_TYPE,
    COUNT(*) AS OLD_COUNT
FROM OLD_SYSTEM.TRANSACTION_LOG
WHERE TXN_DATE = '2026-02-12'
GROUP BY TXN_DATE, TXN_TYPE
ORDER BY TXN_TYPE;

-- 新系統交易筆數
SELECT 
    TXN_DATE,
    TXN_TYPE,
    COUNT(*) AS NEW_COUNT
FROM NEW_SYSTEM.TRANSACTION_LOG
WHERE TXN_DATE = '2026-02-12'
GROUP BY TXN_DATE, TXN_TYPE
ORDER BY TXN_TYPE;

-- 差異比對（JOIN 查詢）
SELECT 
    COALESCE(o.TXN_TYPE, n.TXN_TYPE) AS TXN_TYPE,
    COALESCE(o.OLD_COUNT, 0) AS OLD_COUNT,
    COALESCE(n.NEW_COUNT, 0) AS NEW_COUNT,
    COALESCE(n.NEW_COUNT, 0) - COALESCE(o.OLD_COUNT, 0) AS DIFF
FROM (
    SELECT TXN_TYPE, COUNT(*) AS OLD_COUNT
    FROM OLD_SYSTEM.TRANSACTION_LOG
    WHERE TXN_DATE = '2026-02-12'
    GROUP BY TXN_TYPE
) o
FULL OUTER JOIN (
    SELECT TXN_TYPE, COUNT(*) AS NEW_COUNT
    FROM NEW_SYSTEM.TRANSACTION_LOG
    WHERE TXN_DATE = '2026-02-12'
    GROUP BY TXN_TYPE
) n ON o.TXN_TYPE = n.TXN_TYPE
WHERE COALESCE(o.OLD_COUNT, 0) <> COALESCE(n.NEW_COUNT, 0);

-- ============================================
-- 金額比對：逐筆比對交易金額
-- ============================================
SELECT 
    o.TXN_ID,
    o.ACCOUNT_NO,
    o.TXN_TYPE,
    o.AMOUNT AS OLD_AMOUNT,
    n.AMOUNT AS NEW_AMOUNT,
    ABS(o.AMOUNT - n.AMOUNT) AS DIFF_AMOUNT,
    CASE 
        WHEN o.AMOUNT = n.AMOUNT THEN 'MATCH'
        WHEN ABS(o.AMOUNT - n.AMOUNT) <= 0.01 THEN 'WITHIN_TOLERANCE'
        ELSE 'MISMATCH'
    END AS COMPARE_RESULT
FROM OLD_SYSTEM.TRANSACTION_LOG o
JOIN NEW_SYSTEM.TRANSACTION_LOG n 
    ON o.TXN_ID = n.TXN_ID 
    AND o.TXN_DATE = n.TXN_DATE
WHERE o.TXN_DATE = '2026-02-12'
    AND o.AMOUNT <> n.AMOUNT
ORDER BY ABS(o.AMOUNT - n.AMOUNT) DESC;

-- ============================================
-- 總額比對：比對每日交易總額
-- ============================================
SELECT 
    'OLD_SYSTEM' AS SYSTEM_NAME,
    TXN_DATE,
    TXN_TYPE,
    COUNT(*) AS TXN_COUNT,
    SUM(AMOUNT) AS TOTAL_AMOUNT,
    MIN(AMOUNT) AS MIN_AMOUNT,
    MAX(AMOUNT) AS MAX_AMOUNT,
    AVG(AMOUNT) AS AVG_AMOUNT
FROM OLD_SYSTEM.TRANSACTION_LOG
WHERE TXN_DATE = '2026-02-12'
GROUP BY TXN_DATE, TXN_TYPE

UNION ALL

SELECT 
    'NEW_SYSTEM' AS SYSTEM_NAME,
    TXN_DATE,
    TXN_TYPE,
    COUNT(*) AS TXN_COUNT,
    SUM(AMOUNT) AS TOTAL_AMOUNT,
    MIN(AMOUNT) AS MIN_AMOUNT,
    MAX(AMOUNT) AS MAX_AMOUNT,
    AVG(AMOUNT) AS AVG_AMOUNT
FROM NEW_SYSTEM.TRANSACTION_LOG
WHERE TXN_DATE = '2026-02-12'
GROUP BY TXN_DATE, TXN_TYPE
ORDER BY TXN_TYPE, SYSTEM_NAME;

-- ============================================
-- 找出舊系統有但新系統缺少的交易
-- ============================================
SELECT 
    o.TXN_ID,
    o.ACCOUNT_NO,
    o.TXN_TYPE,
    o.AMOUNT,
    o.TXN_DATETIME,
    'MISSING_IN_NEW' AS ISSUE_TYPE
FROM OLD_SYSTEM.TRANSACTION_LOG o
LEFT JOIN NEW_SYSTEM.TRANSACTION_LOG n 
    ON o.TXN_ID = n.TXN_ID
WHERE n.TXN_ID IS NULL
    AND o.TXN_DATE = '2026-02-12';

-- ============================================
-- 找出新系統有但舊系統沒有的交易（可能是多產出的資料）
-- ============================================
SELECT 
    n.TXN_ID,
    n.ACCOUNT_NO,
    n.TXN_TYPE,
    n.AMOUNT,
    n.TXN_DATETIME,
    'EXTRA_IN_NEW' AS ISSUE_TYPE
FROM NEW_SYSTEM.TRANSACTION_LOG n
LEFT JOIN OLD_SYSTEM.TRANSACTION_LOG o 
    ON n.TXN_ID = o.TXN_ID
WHERE o.TXN_ID IS NULL
    AND n.TXN_DATE = '2026-02-12';

import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 平行測試批次比對引擎
 * 
 * <p>用於比對新舊系統批次產出的結果檔案</p>
 */
public class BatchCompareEngine {

    /** 比對設定 */
    private final CompareConfig config;
    
    /** 差異記錄清單 */
    private final List<DiffRecord> diffRecords = new ArrayList<>();

    public BatchCompareEngine(CompareConfig config) {
        this.config = config;
    }

    /**
     * 執行批次比對
     * 
     * @param oldRecords 舊系統記錄
     * @param newRecords 新系統記錄
     * @return 比對結果報告
     */
    public CompareReport execute(
            List<Map<String, Object>> oldRecords,
            List<Map<String, Object>> newRecords) {

        // 1. 以主鍵建立索引
        Map<String, Map<String, Object>> oldIndex = buildIndex(oldRecords);
        Map<String, Map<String, Object>> newIndex = buildIndex(newRecords);

        // 2. 檢查舊系統有但新系統沒有的記錄
        for (String key : oldIndex.keySet()) {
            if (!newIndex.containsKey(key)) {
                diffRecords.add(new DiffRecord(
                    key, "MISSING_IN_NEW", "整筆記錄",
                    oldIndex.get(key).toString(), "N/A", "S1"
                ));
            }
        }

        // 3. 檢查新系統有但舊系統沒有的記錄
        for (String key : newIndex.keySet()) {
            if (!oldIndex.containsKey(key)) {
                diffRecords.add(new DiffRecord(
                    key, "EXTRA_IN_NEW", "整筆記錄",
                    "N/A", newIndex.get(key).toString(), "S2"
                ));
            }
        }

        // 4. 逐欄比對共同存在的記錄
        for (String key : oldIndex.keySet()) {
            if (newIndex.containsKey(key)) {
                compareFields(key, oldIndex.get(key), newIndex.get(key));
            }
        }

        // 5. 產出報告
        return generateReport(oldRecords.size(), newRecords.size());
    }

    /**
     * 逐欄位比對
     */
    private void compareFields(
            String key,
            Map<String, Object> oldRecord,
            Map<String, Object> newRecord) {

        for (String field : config.getCompareFields()) {
            Object oldVal = oldRecord.get(field);
            Object newVal = newRecord.get(field);
            
            // 取得該欄位的容差設定
            BigDecimal tolerance = config.getTolerance(field);
            
            if (!isEqual(oldVal, newVal, tolerance)) {
                String severity = config.getSeverity(field);
                diffRecords.add(new DiffRecord(
                    key, "FIELD_MISMATCH", field,
                    String.valueOf(oldVal),
                    String.valueOf(newVal),
                    severity
                ));
            }
        }
    }

    /**
     * 判斷兩個值是否相等（含容差判斷）
     */
    private boolean isEqual(Object oldVal, Object newVal, BigDecimal tolerance) {
        if (oldVal == null && newVal == null) return true;
        if (oldVal == null || newVal == null) return false;
        
        // 數值型別：使用容差比對
        if (oldVal instanceof Number && newVal instanceof Number) {
            BigDecimal oldNum = new BigDecimal(oldVal.toString());
            BigDecimal newNum = new BigDecimal(newVal.toString());
            return oldNum.subtract(newNum).abs().compareTo(tolerance) <= 0;
        }
        
        // 其他型別：字串比對
        return oldVal.toString().trim().equals(newVal.toString().trim());
    }

    /**
     * 以主鍵建立索引
     */
    private Map<String, Map<String, Object>> buildIndex(
            List<Map<String, Object>> records) {
        return records.stream().collect(Collectors.toMap(
            r -> config.getPrimaryKeyFields().stream()
                    .map(f -> String.valueOf(r.get(f)))
                    .collect(Collectors.joining("|")),
            r -> r,
            (r1, r2) -> r1 // 重複 key 取第一筆
        ));
    }

    /**
     * 產出比對報告
     */
    private CompareReport generateReport(int oldCount, int newCount) {
        long s1Count = diffRecords.stream()
            .filter(d -> "S1".equals(d.severity())).count();
        long s2Count = diffRecords.stream()
            .filter(d -> "S2".equals(d.severity())).count();

        return new CompareReport(
            oldCount, newCount, diffRecords.size(),
            s1Count, s2Count, diffRecords
        );
    }

    // ===== 內部資料結構 =====

    /** 差異記錄 */
    public record DiffRecord(
        String primaryKey,
        String diffType,
        String fieldName,
        String oldValue,
        String newValue,
        String severity
    ) {}

    /** 比對報告 */
    public record CompareReport(
        int oldSystemCount,
        int newSystemCount,
        int totalDiffs,
        long s1Count,
        long s2Count,
        List<DiffRecord> details
    ) {}
}

/**
 * 比對設定類別
 */
public class CompareConfig {
    
    /** 主鍵欄位 */
    private List<String> primaryKeyFields = List.of("TXN_ID");
    
    /** 需比對的欄位 */
    private List<String> compareFields = List.of(
        "ACCOUNT_NO", "TXN_TYPE", "AMOUNT", 
        "BALANCE", "TXN_DATE", "STATUS"
    );
    
    /** 欄位容差設定 */
    private Map<String, BigDecimal> toleranceMap = Map.of(
        "AMOUNT", new BigDecimal("0.01"),
        "BALANCE", new BigDecimal("0.01"),
        "INTEREST", new BigDecimal("0.001")
    );
    
    /** 欄位嚴重等級 */
    private Map<String, String> severityMap = Map.of(
        "AMOUNT", "S1",    // 金額差異 → 致命
        "BALANCE", "S1",   // 餘額差異 → 致命
        "STATUS", "S2",    // 狀態差異 → 嚴重
        "TXN_DATE", "S2",  // 日期差異 → 嚴重
        "ACCOUNT_NO", "S1" // 帳號差異 → 致命
    );

    // ... getters ...
    
    public BigDecimal getTolerance(String field) {
        return toleranceMap.getOrDefault(field, BigDecimal.ZERO);
    }
    
    public String getSeverity(String field) {
        return severityMap.getOrDefault(field, "S3");
    }
    
    public List<String> getPrimaryKeyFields() { return primaryKeyFields; }
    public List<String> getCompareFields() { return compareFields; }
}

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.net.http.*;
import java.net.URI;
import java.util.*;

/**
 * API 回傳比對工具
 * 
 * <p>同時呼叫新舊系統 API，比對回傳結果</p>
 */
public class ApiCompareClient {

    private final HttpClient httpClient = HttpClient.newHttpClient();
    private final ObjectMapper mapper = new ObjectMapper();
    
    private final String oldSystemBaseUrl;
    private final String newSystemBaseUrl;

    public ApiCompareClient(String oldSystemBaseUrl, String newSystemBaseUrl) {
        this.oldSystemBaseUrl = oldSystemBaseUrl;
        this.newSystemBaseUrl = newSystemBaseUrl;
    }

    /**
     * 比對 API 回傳結果
     * 
     * @param endpoint API 路徑
     * @param requestBody 請求內容
     * @return 比對結果
     */
    public ApiCompareResult compare(String endpoint, String requestBody) 
            throws Exception {
        
        // 1. 呼叫舊系統
        String oldResponse = callApi(oldSystemBaseUrl + endpoint, requestBody);
        
        // 2. 呼叫新系統
        String newResponse = callApi(newSystemBaseUrl + endpoint, requestBody);
        
        // 3. 解析 JSON
        JsonNode oldJson = mapper.readTree(oldResponse);
        JsonNode newJson = mapper.readTree(newResponse);
        
        // 4. 比對
        List<String> diffs = new ArrayList<>();
        compareJsonNodes("", oldJson, newJson, diffs);
        
        return new ApiCompareResult(
            endpoint, oldResponse, newResponse, 
            diffs, diffs.isEmpty()
        );
    }

    /**
     * 遞迴比對 JSON 節點
     */
    private void compareJsonNodes(
            String path, JsonNode oldNode, JsonNode newNode, 
            List<String> diffs) {
        
        if (oldNode == null && newNode == null) return;
        
        if (oldNode == null) {
            diffs.add(String.format("[%s] 舊系統無此欄位, 新系統=%s", 
                path, newNode));
            return;
        }
        if (newNode == null) {
            diffs.add(String.format("[%s] 舊系統=%s, 新系統無此欄位", 
                path, oldNode));
            return;
        }
        
        if (oldNode.isObject()) {
            Iterator<String> fields = oldNode.fieldNames();
            while (fields.hasNext()) {
                String field = fields.next();
                compareJsonNodes(
                    path + "." + field,
                    oldNode.get(field), 
                    newNode.get(field), 
                    diffs
                );
            }
            // 檢查新系統多出的欄位
            Iterator<String> newFields = newNode.fieldNames();
            while (newFields.hasNext()) {
                String field = newFields.next();
                if (!oldNode.has(field)) {
                    diffs.add(String.format(
                        "[%s.%s] 新系統多出欄位=%s", 
                        path, field, newNode.get(field)));
                }
            }
        } else if (!oldNode.equals(newNode)) {
            diffs.add(String.format(
                "[%s] 舊系統=%s, 新系統=%s", 
                path, oldNode, newNode));
        }
    }

    private String callApi(String url, String body) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        
        HttpResponse<String> response = httpClient.send(
            request, HttpResponse.BodyHandlers.ofString());
        return response.body();
    }

    /** API 比對結果 */
    public record ApiCompareResult(
        String endpoint,
        String oldResponse,
        String newResponse,
        List<String> differences,
        boolean isMatch
    ) {}
}

# parallel-test-config.yaml
# 平行測試比對設定檔

compare-jobs:
  - name: "daily-transaction-compare"
    description: "每日交易比對"
    schedule: "0 2 * * *"  # 每日凌晨 2 點執行
    source:
      old-system:
        type: database
        connection: "jdbc:oracle:thin:@old-host:1521:OLDDB"
        query: "SELECT * FROM TRANSACTION_LOG WHERE TXN_DATE = :date"
      new-system:
        type: database
        connection: "jdbc:postgresql://new-host:5432/newdb"
        query: "SELECT * FROM transaction_log WHERE txn_date = :date"
    
    primary-key: ["txn_id"]
    
    compare-fields:
      - field: "account_no"
        type: string
        severity: S1
      - field: "amount"
        type: decimal
        severity: S1
        tolerance: 0.01
      - field: "balance"
        type: decimal
        severity: S1
        tolerance: 0.01
      - field: "txn_type"
        type: string
        severity: S2
      - field: "status"
        type: string
        severity: S2
    
    exclude-fields: ["created_at", "updated_at", "system_id"]
    
    report:
      format: ["html", "csv", "json"]
      output-dir: "/reports/parallel-test/"
      notify:
        - type: email
          recipients: ["team@company.com"]
          condition: "has_s1_diff"
        - type: slack
          channel: "#parallel-test"
          condition: "always"

// Jenkinsfile - 平行測試 Pipeline
pipeline {
    agent any
    
    parameters {
        string(name: 'TEST_DATE', defaultValue: '', 
               description: '測試日期 (YYYY-MM-DD)')
        choice(name: 'TEST_SCOPE', choices: ['DAILY', 'MONTHLY', 'FULL'],
               description: '測試範圍')
    }
    
    environment {
        OLD_SYSTEM_URL = credentials('old-system-url')
        NEW_SYSTEM_URL = credentials('new-system-url')
    }
    
    stages {
        stage('環境檢查') {
            steps {
                script {
                    echo "檢查新舊系統連線狀態..."
                    sh './scripts/check-connectivity.sh'
                }
            }
        }
        
        stage('資料擷取') {
            parallel {
                stage('擷取舊系統資料') {
                    steps {
                        sh """
                            java -jar parallel-test-tool.jar extract \
                                --system old \
                                --date ${params.TEST_DATE} \
                                --scope ${params.TEST_SCOPE}
                        """
                    }
                }
                stage('擷取新系統資料') {
                    steps {
                        sh """
                            java -jar parallel-test-tool.jar extract \
                                --system new \
                                --date ${params.TEST_DATE} \
                                --scope ${params.TEST_SCOPE}
                        """
                    }
                }
            }
        }
        
        stage('執行比對') {
            steps {
                sh """
                    java -jar parallel-test-tool.jar compare \
                        --date ${params.TEST_DATE} \
                        --config parallel-test-config.yaml
                """
            }
        }
        
        stage('產出報告') {
            steps {
                sh """
                    java -jar parallel-test-tool.jar report \
                        --date ${params.TEST_DATE} \
                        --format html,csv
                """
                publishHTML(target: [
                    reportDir: 'reports',
                    reportFiles: 'parallel-test-report.html',
                    reportName: '平行測試報告'
                ])
            }
        }
        
        stage('差異檢查') {
            steps {
                script {
                    def result = readJSON file: 'reports/summary.json'
                    if (result.s1_count > 0) {
                        currentBuild.result = 'FAILURE'
                        error "發現 ${result.s1_count} 筆 S1 差異！"
                    }
                    if (result.s2_count > 0) {
                        currentBuild.result = 'UNSTABLE'
                        echo "警告：發現 ${result.s2_count} 筆 S2 差異"
                    }
                }
            }
        }
    }
    
    post {
        failure {
            emailext(
                subject: "⚠️ 平行測試失敗 - ${params.TEST_DATE}",
                body: '${FILE,path="reports/parallel-test-report.html"}',
                to: 'team@company.com'
            )
        }
        always {
            archiveArtifacts artifacts: 'reports/**', fingerprint: true
        }
    }
}

# .github/workflows/parallel-test.yml
name: Parallel Test

on:
  schedule:
    - cron: '0 18 * * 1-5'  # UTC 18:00 = 台灣凌晨 2:00
  workflow_dispatch:
    inputs:
      test_date:
        description: '測試日期'
        required: true
        type: string

jobs:
  parallel-test:
    runs-on: ubuntu-latest
    
    steps:
      - uses: actions/checkout@v4
      
      - name: Set up JDK 21
        uses: actions/setup-java@v4
        with:
          java-version: '21'
          distribution: 'temurin'
      
      - name: Run Compare
        run: |
          java -jar tools/parallel-test-tool.jar compare \
            --date ${{ github.event.inputs.test_date || 'today' }} \
            --config config/parallel-test-config.yaml
      
      - name: Upload Report
        uses: actions/upload-artifact@v4
        with:
          name: parallel-test-report
          path: reports/
      
      - name: Check Results
        run: |
          S1_COUNT=$(jq '.s1_count' reports/summary.json)
          if [ "$S1_COUNT" -gt 0 ]; then
            echo "::error::發現 $S1_COUNT 筆 S1 致命差異！"
            exit 1
          fi

╔══════════════════════════════════════════════════════╗
║     平行測試每日摘要報表                               ║
║     日期：2026-02-12                                  ║
╠══════════════════════════════════════════════════════╣
║                                                      ║
║  📊 比對統計                                          ║
║  ├─ 舊系統筆數：125,430                               ║
║  ├─ 新系統筆數：125,430                               ║
║  ├─ 比對筆數　：125,430                               ║
║  └─ 差異筆數　：3                                     ║
║                                                      ║
║  🔍 差異分布                                          ║
║  ├─ S1 致命：0                                       ║
║  ├─ S2 嚴重：1                                       ║
║  ├─ S3 一般：1                                       ║
║  └─ S4 輕微：1                                       ║
║                                                      ║
║  📈 趨勢                                             ║
║  ├─ 較昨日差異：減少 2 筆 ✅                           ║
║  └─ 連續零 S1 天數：5 天                              ║
║                                                      ║
║  ⚡ 效能指標                                          ║
║  ├─ 批次執行時間（舊）：45 min                         ║
║  ├─ 批次執行時間（新）：38 min                         ║
║  └─ 效能改善：15.6% ✅                                ║
║                                                      ║
╚══════════════════════════════════════════════════════╝

日誌寫入 → 即時雜湊（SHA-256） → 寫入區塊鏈或 WORM 儲存 → 定期驗證完整性

1. 稽核範圍與期間
2. 稽核方法
3. 查核發現
   3.1 合規事項
   3.2 不合規事項（含嚴重等級）
4. 改善建議
5. 管理層回應
6. 後續追蹤計畫

╔══════════════════════════════════════════════════════╗
║               上  線  核  准  單                      ║
╠══════════════════════════════════════════════════════╣
║                                                      ║
║  專案名稱：____________________                       ║
║  系統名稱：____________________                       ║
║  預定上線日期：____/__/__                             ║
║  申請人：__________  日期：____/__/__                  ║
║                                                      ║
╠══════════════════════════════════════════════════════╣
║  一、平行測試結果摘要                                  ║
║                                                      ║
║  測試期間：____/__/__ ～ ____/__/__                    ║
║  測試輪次：共 __ 輪                                   ║
║  最終差異數：S1=__ S2=__ S3=__ S4=__                  ║
║  連續零 S1 天數：____ 天                              ║
║                                                      ║
╠══════════════════════════════════════════════════════╣
║  二、核准條件確認                                      ║
║                                                      ║
║  □ S1 差異歸零                                       ║
║  □ S2 差異歸零                                       ║
║  □ 連續 3 天無新增 S1/S2 差異                         ║
║  □ 效能符合 SLA                                      ║
║  □ 回滾計畫已演練                                     ║
║  □ 運維團隊準備就緒                                   ║
║  □ 法遵審核通過                                      ║
║                                                      ║
╠══════════════════════════════════════════════════════╣
║  三、核准簽章                                         ║
║                                                      ║
║  PM：__________ 簽章：________ 日期：____/__/__        ║
║  測試Lead：_____ 簽章：________ 日期：____/__/__       ║
║  業務代表：_____ 簽章：________ 日期：____/__/__       ║
║  風控主管：_____ 簽章：________ 日期：____/__/__       ║
║  法遵代表：_____ 簽章：________ 日期：____/__/__       ║
║  高階主管：_____ 簽章：________ 日期：____/__/__       ║
║                                                      ║
╠══════════════════════════════════════════════════════╣
║  四、核准結果                                         ║
║                                                      ║
║  □ 核准上線    □ 延後上線    □ 退回補件              ║
║                                                      ║
║  備註：                                               ║
║  ________________________________________________    ║
║  ________________________________________________    ║
║                                                      ║
╚══════════════════════════════════════════════════════╝

全量比對（推薦）  ────────────────────────  抽樣比對（退而求其次）
   │                                              │
   ├─ 核心系統必須全量                                ├─ 非核心系統可抽樣
   ├─ 金融數據必須全量                                ├─ 抽樣率 ≥ 30%
   └─ 監理報表必須全量                                └─ 必須覆蓋所有類型

/**
 * 資料標準化處理 - 在比對前統一資料格式
 * 
 * <p>避免因格式差異產生假性差異</p>
 */
public class DataNormalizer {

    /**
     * 標準化金額欄位
     * - 統一使用 BigDecimal
     * - 統一小數位數
     * - 去除千分位符號
     */
    public BigDecimal normalizeAmount(String value, int scale) {
        if (value == null || value.isBlank()) {
            return BigDecimal.ZERO;
        }
        String cleaned = value.replaceAll("[,$\\s]", "");
        return new BigDecimal(cleaned)
            .setScale(scale, RoundingMode.HALF_UP);
    }

    /**
     * 標準化日期欄位
     * - 統一為 ISO 格式 (yyyy-MM-dd)
     * - 處理不同分隔符號
     */
    public String normalizeDate(String value) {
        if (value == null || value.isBlank()) return "";
        // 處理常見格式：2026/02/12、20260212、2026-02-12
        String cleaned = value.replaceAll("[/\\-.]", "");
        if (cleaned.length() == 8) {
            return cleaned.substring(0, 4) + "-" 
                 + cleaned.substring(4, 6) + "-" 
                 + cleaned.substring(6, 8);
        }
        return value;
    }

    /**
     * 標準化文字欄位
     * - 去除前後空白
     * - 統一全形/半形
     * - 統一大小寫（依設定）
     */
    public String normalizeText(String value, boolean caseInsensitive) {
        if (value == null) return "";
        String result = value.trim();
        if (caseInsensitive) {
            result = result.toUpperCase();
        }
        return result;
    }
}