#include "plate_swap.hpp"
#include <fstream>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cstring>
#include <filesystem>

namespace fs = std::filesystem;
using namespace cv;
using namespace std;

namespace ice {

// ═══════════════════════════════════════════════════════════
// CCPD 文件名解析
// ═══════════════════════════════════════════════════════════

CCPDMeta parse_ccpd_filename(const string& filename) {
    CCPDMeta meta;
    meta.valid = false;

    // 提取不带扩展名的部分
    fs::path p(filename);
    string stem = p.stem().string();
    
    // 按 '-' 分割
    vector<string> parts;
    size_t pos = 0;
    while (pos < stem.size()) {
        size_t dash = stem.find('-', pos);
        if (dash == string::npos) {
            parts.push_back(stem.substr(pos));
            break;
        }
        parts.push_back(stem.substr(pos, dash - pos));
        pos = dash + 1;
    }
    
    if (parts.size() < 5) return meta;
    
    try {
        // parts[3] = 4角点
        string& coords = parts[3];
        vector<Point2f> pts;
        size_t start = 0;
        while (start < coords.size()) {
            size_t us = coords.find('_', start);
            string pt = (us == string::npos) ? coords.substr(start) : coords.substr(start, us - start);
            size_t amp = pt.find('&');
            if (amp == string::npos) break;
            float x = stof(pt.substr(0, amp));
            float y = stof(pt.substr(amp + 1));
            pts.push_back({x, y});
            if (us == string::npos) break;
            start = us + 1;
        }
        
        if (pts.size() != 4) return meta;
        
        // 几何排序: TL=min(x+y), TR=max(x-y), BR=max(x+y), BL=min(x-y)
        float sums[4], diffs[4];
        for (int i = 0; i < 4; i++) {
            sums[i] = pts[i].x + pts[i].y;
            diffs[i] = pts[i].x - pts[i].y;
        }
        int tl = (int)(min_element(sums, sums+4) - sums);
        int tr = (int)(max_element(diffs, diffs+4) - diffs);
        int br = (int)(max_element(sums, sums+4) - sums);
        int bl = (int)(min_element(diffs, diffs+4) - diffs);
        
        meta.corners[0] = pts[tl];
        meta.corners[1] = pts[tr];
        meta.corners[2] = pts[br];
        meta.corners[3] = pts[bl];
        meta.valid = true;
    } catch (...) {
        meta.valid = false;
    }
    
    return meta;
}


// ═══════════════════════════════════════════════════════════
// 合成车牌池
// ═══════════════════════════════════════════════════════════

void PlatePool::load(const string& dir) {
    // Fallback: load from directory
    for (auto& entry : fs::directory_iterator(dir)) {
        if (!entry.is_directory()) continue;
        string bg_color = entry.path().filename().string();
        vector<PlateEntry>& vec = pools_[bg_color];
        
        for (auto& f : fs::directory_iterator(entry.path())) {
            if (!f.is_regular_file()) continue;
            string ext = f.path().extension().string();
            if (ext != ".jpg" && ext != ".png" && ext != ".PNG") continue;
            
            Mat img = imread_unicode(f.path().string());
            if (img.empty()) continue;
            
            PlateEntry pe;
            pe.image = img;
            vec.push_back(pe);
        }
    }
}

void PlatePool::load_bin(const string& bin_path) {
    ifstream f(bin_path, ios::binary);
    if (!f) { cerr << "[WARN] pool.bin not found" << endl; return; }
    
    char magic[4];
    f.read(magic, 4);
    if (memcmp(magic, "IPPL", 4) != 0) { cerr << "[WARN] bad magic" << endl; return; }
    
    uint32_t num_types;
    f.read((char*)&num_types, 4);
    
    for (uint32_t ti = 0; ti < num_types; ti++) {
        uint32_t name_len;
        f.read((char*)&name_len, 4);
        string plate_type(name_len, 0);
        f.read(&plate_type[0], name_len);
        
        uint32_t count;
        f.read((char*)&count, 4);
        
        vector<PlateEntry>& vec = pools_[plate_type];
        vec.reserve(count);
        
        for (uint32_t pi = 0; pi < count; pi++) {
            uint32_t w, h, data_len;
            f.read((char*)&w, 4);
            f.read((char*)&h, 4);
            f.read((char*)&data_len, 4);
            
            vector<uint8_t> buf(data_len);
            f.read((char*)buf.data(), data_len);
            
            PlateEntry pe;
            pe.image = Mat(h, w, CV_8UC3, buf.data()).clone();
            
            // Read plate number metadata
            uint32_t num_len;
            f.read((char*)&num_len, 4);
            pe.plate_number.resize(num_len);
            f.read(&pe.plate_number[0], num_len);
            
            vec.push_back(pe);
        }
    }
}

const PlateEntry& PlatePool::random(const string& plate_type, mt19937& rng) {
    auto& vec = pools_[plate_type];
    if (vec.empty()) {
        for (auto& [k, v] : pools_) {
            if (!v.empty()) {
                uniform_int_distribution<size_t> dist(0, v.size()-1);
                return v[dist(rng)];
            }
        }
        throw runtime_error("PlatePool is empty");
    }
    uniform_int_distribution<size_t> dist(0, vec.size()-1);
    return vec[dist(rng)];
}

size_t PlatePool::count(const string& plate_type) const {
    auto it = pools_.find(plate_type);
    return (it != pools_.end()) ? it->second.size() : 0;
}


// Helper: plate_type → bg_color for color matching
static string bg_color_of(const string& plate_type) {
    if (plate_type == "police") return "white";
    if (plate_type == "army") return "white_army";
    if (plate_type == "gangao") return "black";
    if (plate_type == "shiguan_old" || plate_type == "shiguan_new") return "black_shi";
    if (plate_type == "lingguan_old" || plate_type == "lingguan_new") return "black";
    if (plate_type == "coach") return "yellow";
    if (plate_type == "new_energy") return "green_truck";
    return "white";
}


// ═══════════════════════════════════════════════════════════
// Unicode 文件读写
// ═══════════════════════════════════════════════════════════

Mat imread_unicode(const string& path) {
    ifstream f(fs::path(path), ios::binary);
    if (!f) return Mat();
    vector<uint8_t> data((istreambuf_iterator<char>(f)), istreambuf_iterator<char>());
    return imdecode(data, IMREAD_COLOR);
}

bool imwrite_unicode(const string& path, const Mat& img, const vector<int>& params) {
    vector<uint8_t> buf;
    fs::path p(path);
    string ext = p.extension().string();
    if (!imencode(ext, img, buf, params)) return false;
    // Use fs::path directly for proper Unicode support on Windows
    ofstream f(p, ios::binary);
    if (!f) return false;
    f.write(reinterpret_cast<const char*>(buf.data()), buf.size());
    return f.good();
}


// ═══════════════════════════════════════════════════════════
// 透视提取车牌 ROI
// ═══════════════════════════════════════════════════════════

Mat extract_plate_roi(const Mat& img, const Point2f corners[4],
                      int plate_w, int plate_h) {
    Point2f dst[4] = {
        {0, 0},
        {(float)(plate_w - 1), 0},
        {(float)(plate_w - 1), (float)(plate_h - 1)},
        {0, (float)(plate_h - 1)}
    };
    Mat M = getPerspectiveTransform(corners, dst);
    Mat roi;
    warpPerspective(img, roi, M, Size(plate_w, plate_h),
                    INTER_LINEAR, BORDER_REPLICATE);
    return roi;
}


// ═══════════════════════════════════════════════════════════
// 色温匹配
// ═══════════════════════════════════════════════════════════

Mat match_plate_color(const Mat& synthetic, const Mat& orig_roi,
                      const string& bg_color) {
    Mat syn, orig;
    synthetic.convertTo(syn, CV_32F);
    orig_roi.convertTo(orig, CV_32F);

    // 尺寸对齐
    if (syn.size() != orig.size())
        resize(syn, syn, orig.size(), 0, 0, INTER_LINEAR);

    if (bg_color == "black" || bg_color == "black_shi") {
        Mat orig_gray;
        cvtColor(orig_roi, orig_gray, COLOR_BGR2GRAY);
        double thresh_val;
        {
            Mat sorted;
            orig_gray.reshape(1, 1).copyTo(sorted);
            cv::sort(sorted, sorted, SORT_EVERY_ROW + SORT_ASCENDING);
            int idx = (int)(sorted.cols * 0.90);
            thresh_val = sorted.at<uint8_t>(0, idx);
        }
        Mat white_mask = orig_gray > thresh_val;
        if (countNonZero(white_mask) < 50) return synthetic;

        Scalar white_ref = mean(orig, white_mask);
        float ref_mean = (float)(white_ref[0] + white_ref[1] + white_ref[2]) / 3.0f;
        if (ref_mean < 10) return synthetic;

        Scalar color_cast(white_ref[0]/ref_mean, white_ref[1]/ref_mean, white_ref[2]/ref_mean);
        Scalar amplified(1.0f + (color_cast[0]-1.0f), 1.0f+(color_cast[1]-1.0f), 1.0f+(color_cast[2]-1.0f));
        amplified[0] = std::clamp((double)amplified[0], 0.85, 1.15);
        amplified[1] = std::clamp((double)amplified[1], 0.85, 1.15);
        amplified[2] = std::clamp((double)amplified[2], 0.85, 1.15);

        Mat syn_gray;
        cvtColor(synthetic, syn_gray, COLOR_BGR2GRAY);
        Mat alpha;
        syn_gray.convertTo(alpha, CV_32F, 1.0/128.0);
        alpha = max(0.0f, min(1.0f, alpha));

        Mat result = syn.clone();
        for (int c = 0; c < 3; c++) {
            Mat ch_syn, ch_res;
            extractChannel(syn, ch_syn, c);
            ch_res = ch_syn.mul(1.0f + ((float)amplified[c] - 1.0f) * alpha);
            ch_res.setTo(0, ch_res < 0);
            ch_res.setTo(255, ch_res > 255);
            insertChannel(ch_res, result, c);
        }
        result.convertTo(result, CV_8U);
        return result;
    }

    // 亮底牌：提取白参考
    Mat orig_gray;
    cvtColor(orig_roi, orig_gray, COLOR_BGR2GRAY);
    double thresh_val;
    {
        Mat sorted;
        orig_gray.reshape(1, 1).copyTo(sorted);
        cv::sort(sorted, sorted, SORT_EVERY_ROW + SORT_ASCENDING);
        int idx = (int)(sorted.cols * 0.90);
        thresh_val = sorted.at<uint8_t>(0, idx);
    }
    Mat white_mask = orig_gray > thresh_val;
    if (countNonZero(white_mask) < 50) return synthetic;

    Scalar white_ref = mean(orig, white_mask);
    float ref_mean = (float)(white_ref[0] + white_ref[1] + white_ref[2]) / 3.0f;
    if (ref_mean < 10) return synthetic;

    if (bg_color == "yellow") {
        Scalar gain = white_ref / 255.0;
        gain[0] = std::clamp((float)gain[0], 0.6f, 1.3f);
        gain[1] = std::clamp((float)gain[1], 0.6f, 1.3f);
        gain[2] = std::clamp((float)gain[2], 0.6f, 1.3f);
        Mat res;
        multiply(syn, gain, res);
        res.setTo(0, res < 0);
        res.setTo(255, res > 255);
        res.convertTo(res, CV_8U);
        return res;
    }

    // 白/绿牌
    Scalar color_cast(white_ref[0]/ref_mean, white_ref[1]/ref_mean, white_ref[2]/ref_mean);
    float strength = (bg_color == "green_truck") ? 1.5f : 1.0f;
    Scalar amplified(1.0f + (color_cast[0]-1.0f)*strength, 1.0f+(color_cast[1]-1.0f)*strength, 1.0f+(color_cast[2]-1.0f)*strength);
    amplified[0] = std::clamp((float)amplified[0], 0.85f, 1.15f);
    amplified[1] = std::clamp((float)amplified[1], 0.85f, 1.15f);
    amplified[2] = std::clamp((float)amplified[2], 0.85f, 1.15f);

    Mat syn_gray;
    cvtColor(synthetic, syn_gray, COLOR_BGR2GRAY);
    Mat alpha;
    syn_gray.convertTo(alpha, CV_32F, 1.0/128.0);
    alpha = max(0.0f, min(1.0f, alpha));

    Mat result = syn.clone();
    for (int c = 0; c < 3; c++) {
        Mat ch_syn, ch_res;
        extractChannel(syn, ch_syn, c);
        ch_res = ch_syn.mul(1.0f + (amplified[c] - 1.0f) * alpha);
        ch_res.setTo(0, ch_res < 0);
        ch_res.setTo(255, ch_res > 255);
        insertChannel(ch_res, result, c);
    }
    result.convertTo(result, CV_8U);
    return result;
}


// ═══════════════════════════════════════════════════════════
// 底板色校正
// ═══════════════════════════════════════════════════════════

Mat fix_bg_color(const Mat& plate, const string& bg_color,
                 int h_shift, int s_scale, int v_scale) {
    if (h_shift == 0 && s_scale == 100 && v_scale == 100)
        return plate;

    int h_lo = 0, h_hi = 180;
    if (bg_color == "yellow") { h_lo = 15; h_hi = 50; }
    else if (bg_color == "green_truck") { h_lo = 40; h_hi = 85; }

    Mat hsv;
    cvtColor(plate, hsv, COLOR_BGR2HSV);
    hsv.convertTo(hsv, CV_32F);

    vector<Mat> ch(3);
    split(hsv, ch);
    Mat &H = ch[0], &S = ch[1], &V = ch[2];

    Mat bg_mask = (H > h_lo) & (H < h_hi) & (S > 80) & (V > 100);
    if (countNonZero(bg_mask) < 200) return plate;

    // 距离变换羽化
    Mat bg_u8, dist;
    bg_mask.convertTo(bg_u8, CV_8U, 255);
    distanceTransform(bg_u8, dist, DIST_L2, DIST_MASK_PRECISE);
    Mat soft;
    dist.convertTo(soft, CV_32F, 1.0/4.0);
    soft = max(0.0f, min(1.0f, soft));

    H = H + h_shift * soft;
    S = S.mul(1.0f + (s_scale / 100.0f - 1.0f) * soft);
    V = V.mul(1.0f + (v_scale / 100.0f - 1.0f) * soft);

    H.setTo(0, H < 0); H.setTo(180, H > 180);
    S.setTo(0, S < 0); S.setTo(255, S > 255);
    V.setTo(0, V < 0); V.setTo(255, V > 255);

    Mat result;
    merge(ch, hsv);
    hsv.convertTo(hsv, CV_8U);
    cvtColor(hsv, result, COLOR_HSV2BGR);
    return result;
}


// ═══════════════════════════════════════════════════════════
// 透视回贴
// ═══════════════════════════════════════════════════════════

pair<Mat, Mat> warp_plate_back(const Mat& plate, const Point2f dst_corners[4],
                                Size output_size) {
    int h = plate.rows, w = plate.cols;
    Point2f src[4] = {
        {0, 0}, {(float)(w-1), 0}, {(float)(w-1), (float)(h-1)}, {0, (float)(h-1)}
    };

    Mat M = getPerspectiveTransform(src, dst_corners);
    Mat warped, mask_warped;
    warpPerspective(plate, warped, M, output_size, INTER_LINEAR, BORDER_CONSTANT, Scalar(0,0,0));

    Mat mask(h, w, CV_8UC1, Scalar(255));
    warpPerspective(mask, mask_warped, M, output_size, INTER_LINEAR, BORDER_CONSTANT, Scalar(0));

    return {warped, mask_warped};
}


// ═══════════════════════════════════════════════════════════
// 羽化贴合
// ═══════════════════════════════════════════════════════════

Mat feather_blend(const Mat& original, const Mat& warped,
                  const Mat& mask, int edge_width) {
    Mat mask_u8;
    mask.convertTo(mask_u8, CV_8U);
    
    if (countNonZero(mask_u8) < 100) {
        Mat result = original.clone();
        warped.copyTo(result, mask_u8);
        return result;
    }

    // Fast blend: erode mask slightly for edge transition, no expensive distanceTransform
    Mat eroded;
    int ksize = max(3, edge_width) | 1;  // ensure odd
    Mat kernel = getStructuringElement(MORPH_ELLIPSE, Size(ksize, ksize));
    erode(mask_u8, eroded, kernel);
    
    Mat alpha;
    eroded.convertTo(alpha, CV_32F, 1.0/255.0);
    // Soften edges with a small blur
    GaussianBlur(alpha, alpha, Size(ksize, ksize), ksize/3.0);

    Mat result(original.size(), CV_32FC3);
    Mat warped_f, orig_f;
    warped.convertTo(warped_f, CV_32F);
    original.convertTo(orig_f, CV_32F);

    for (int c = 0; c < 3; c++) {
        Mat wc, oc;
        extractChannel(warped_f, wc, c);
        extractChannel(orig_f, oc, c);
        Mat rc = wc.mul(alpha) + oc.mul(1.0f - alpha);
        rc.setTo(0, rc < 0);
        rc.setTo(255, rc > 255);
        insertChannel(rc, result, c);
    }
    result.convertTo(result, CV_8U);
    return result;
}


// ═══════════════════════════════════════════════════════════
// 噪声匹配
// ═══════════════════════════════════════════════════════════

Mat match_noise(const Mat& blended, const Mat& original, const Mat& mask) {
    Mat mask_u8;
    mask.convertTo(mask_u8, CV_8U);
    if (countNonZero(mask_u8) < 100) return blended;

    // Crop plate region for noise estimation (like Python's plate_crop)
    vector<Point> pts;
    findNonZero(mask_u8, pts);
    if (pts.size() < 200) return blended;

    int bw = blended.cols, bh = blended.rows;
    int xmin = bw, xmax = 0, ymin = bh, ymax = 0;
    for (auto& p : pts) {
        if (p.x < xmin) xmin = p.x;
        if (p.x > xmax) xmax = p.x;
        if (p.y < ymin) ymin = p.y;
        if (p.y > ymax) ymax = p.y;
    }
    int x1 = max(0, xmin - 5), x2 = min(bw, xmax + 5);
    int y1 = max(0, ymin - 5), y2 = min(bh, ymax + 5);
    Mat plate_crop = original(Rect(x1, y1, x2-x1, y2-y1));

    // 1) Noise sigma from original plate crop
    Mat crop_blurred, crop_residual;
    GaussianBlur(plate_crop, crop_blurred, Size(5,5), 1.0);
    Mat crop_f32, blur_f32;
    plate_crop.convertTo(crop_f32, CV_32F);
    crop_blurred.convertTo(blur_f32, CV_32F);
    crop_residual = crop_f32 - blur_f32;
    Scalar stddev;
    meanStdDev(crop_residual, Scalar(), stddev);
    float noise_sigma = (float)max(stddev[0], max(stddev[1], max(stddev[2], 1.5)));

    // 2) Blur sigma from original plate crop
    Mat crop_gray;
    cvtColor(plate_crop, crop_gray, COLOR_BGR2GRAY);
    Mat lap;
    Laplacian(crop_gray, lap, CV_64F);
    Scalar lap_m, lap_s;
    meanStdDev(lap, lap_m, lap_s);
    float lap_var = (float)(lap_s[0] * lap_s[0]);
    float blur_sigma = 0;
    if (lap_var < 50) blur_sigma = 2.0f;
    else if (lap_var < 200) blur_sigma = 1.2f;
    else if (lap_var < 500) blur_sigma = 0.5f;

    // Apply blur to plate area
    Mat result = blended.clone();
    if (blur_sigma > 0.1f) {
        Mat blurred_full;
        GaussianBlur(result, blurred_full, Size(0,0), blur_sigma);
        blurred_full.copyTo(result, mask_u8);
    }

    // Add noise to plate area only
    Mat result_f;
    result.convertTo(result_f, CV_32F);
    Mat noise(result.size(), CV_32FC3);
    randn(noise, Scalar(0,0,0), Scalar(noise_sigma, noise_sigma, noise_sigma));
    Mat noisy = result_f + noise;

    // Alpha blend: noise in plate area, clean outside
    Mat alpha;
    mask_u8.convertTo(alpha, CV_32F, 1.0/255.0);
    Mat alpha_3;
    merge(vector<Mat>{alpha, alpha, alpha}, alpha_3);
    Mat one_minus_a;
    subtract(Scalar::all(1.0), alpha_3, one_minus_a);
    noisy = noisy.mul(alpha_3) + result_f.mul(one_minus_a);

    // Clip AFTER blend (matching Python np.clip order)
    noisy.setTo(0, noisy < 0);
    noisy.setTo(255, noisy > 255);
    noisy.convertTo(result, CV_8U);
    return result;
}

Mat degrade_plate(const Mat& plate) {
    Mat result = plate.clone();
    
    // JPEG 极限压缩
    vector<uint8_t> buf;
    imencode(".jpg", result, buf, {IMWRITE_JPEG_QUALITY, 2});
    result = imdecode(buf, IMREAD_COLOR);

    // 降采样升采样
    int w = result.cols, h = result.rows;
    Mat small;
    resize(result, small, Size(w/4, h/4), 0, 0, INTER_LINEAR);
    resize(small, result, Size(w, h), 0, 0, INTER_NEAREST);
    
    // 模糊
    GaussianBlur(result, result, Size(5,5), 1.5);
    
    return result;
}


// ═══════════════════════════════════════════════════════════
// 单张处理
// ═══════════════════════════════════════════════════════════

bool process_single(const string& img_path, const SwapConfig& cfg,
                    PlatePool& pool, mt19937& rng, const CCPDMeta* pre_meta) {
    // 1. 解析文件名 (use pre-parsed if available)
    fs::path fp(img_path);
    CCPDMeta meta;
    if (pre_meta && pre_meta->valid) {
        meta = *pre_meta;
    } else {
        meta = parse_ccpd_filename(fp.filename().string());
        if (!meta.valid) return false;
    }

    // 2. 读原图
    Mat img_orig = imread_unicode(img_path);
    if (img_orig.empty()) return false;

    int h_img = img_orig.rows, w_img = img_orig.cols;

    // 校验角点
    for (int i = 0; i < 4; i++) {
        auto& c = meta.corners[i];
        if (c.x < 0 || c.y < 0 || c.x > w_img*1.5 || c.y > h_img*1.5)
            return false;
    }

    // 3. Pick from pool
    string bg_color = bg_color_of(cfg.plate_type);
    const PlateEntry& entry = pool.random(cfg.plate_type, rng);
    Mat synthetic = entry.image.clone();
    int plate_w = synthetic.cols, plate_h = synthetic.rows;
    string plate_number = entry.plate_number;

    // 4. Extract original ROI
    Mat orig_roi = extract_plate_roi(img_orig, meta.corners, plate_w, plate_h);


    // 5. Fix bg color
    synthetic = fix_bg_color(synthetic, bg_color,
                              cfg.h_shift, cfg.s_scale, cfg.v_scale);

    // 6. Color match
    Mat matched = match_plate_color(synthetic, orig_roi, bg_color);

    // 7. Brightness match
    Mat orig_gray, matched_gray;
    cvtColor(orig_roi, orig_gray, COLOR_BGR2GRAY);
    cvtColor(matched, matched_gray, COLOR_BGR2GRAY);

    auto p95 = [](const Mat& m) -> float {
        Mat sorted;
        m.reshape(1,1).copyTo(sorted);
        cv::sort(sorted, sorted, SORT_EVERY_ROW + SORT_ASCENDING);
        return sorted.at<uint8_t>(0, (int)(sorted.cols * 0.95));
    };
    float target_w = p95(orig_gray);
    float current_w = p95(matched_gray);

    if (current_w > 10 && abs(target_w - current_w) > 10) {
        float l_ratio = target_w / current_w;
        float min_c = 0.5f, max_c = 1.1f;
        if (bg_color == "green_truck" || bg_color == "yellow") { min_c = 0.4f; max_c = 1.0f; }
        else if (bg_color == "black" || bg_color == "black_shi") { min_c = 0.3f; max_c = 1.2f; }
        l_ratio = std::clamp(l_ratio, min_c, max_c);

        Mat alpha;
        matched_gray.convertTo(alpha, CV_32F, 1.0/128.0);
        alpha = max(0.3f, min(1.0f, alpha));

        Mat matched_f;
        matched.convertTo(matched_f, CV_32F);
        for (int c = 0; c < 3; c++) {
            Mat ch;
            extractChannel(matched_f, ch, c);
            ch = ch.mul(1.0f + (l_ratio - 1.0f) * alpha);
            ch.setTo(0, ch < 0); ch.setTo(255, ch > 255);
            insertChannel(ch, matched_f, c);
        }
        matched_f.convertTo(matched, CV_8U);
    }

    // 8. Degradation
    if (!cfg.fast_mode)
        matched = degrade_plate(matched);

    // 9-11. Warp + blend + noise
    auto [warped, mask] = warp_plate_back(matched, meta.corners, Size(w_img, h_img));
    Mat blended = feather_blend(img_orig, warped, mask);
    Mat final = match_noise(blended, img_orig, mask);

    // 12. Save with pinyin tags
    string stem = fp.stem().string();
    // Convert Chinese plate markers to ASCII tags
    string tag = plate_number;
    // Manual pinyin mapping for common plate characters (UTF-8 byte sequences)
    // 港=E6B8AF 澳=E6BEB3 警=E8ADA6 使=E4BDBF 领=E9A286 学=E5ADA6
    struct { const char* utf8; const char* py; } map[] = {
        {"\xE6\xB8\xAF", "GANG"}, {"\xE6\xBE\xB3", "AO"},
        {"\xE8\xAD\xA6", "JING"}, {"\xE4\xBD\xBF", "SHI"},
        {"\xE9\xA2\x86", "LING"}, {"\xE5\xAD\xA6", "XUE"},
    };
    for (auto& m : map) {
        size_t pos = 0;
        while ((pos = tag.find(m.utf8, pos)) != string::npos) {
            tag.replace(pos, 3, m.py);
            pos += strlen(m.py);
        }
    }
    // Remove any remaining non-ASCII
    string clean;
    for (char c : tag) {
        if ((unsigned char)c < 128) clean += c;
    }
    string out_name = stem + "__" + cfg.plate_type + "__" + clean + ".jpg";
    string ccpd_subdir = fp.parent_path().filename().string();
    fs::path out_dir = fs::path(cfg.output_dir) / ccpd_subdir / cfg.plate_type;
    fs::create_directories(out_dir);
    
    return imwrite_unicode((out_dir / out_name).string(), final, {IMWRITE_JPEG_QUALITY, 75});
}

} // namespace ice