#include <target_exposure_control/exposure_control.hpp>
#include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <limits>
#include <stdexcept>
#include <string>
#include <vector>

using namespace target_exposure;
namespace {
struct Case { std::string group, name; std::function<void()> run; };
std::vector<Case>& cases() { static std::vector<Case> value; return value; }
bool registerCase(const char* group, const char* name, std::function<void()> run) {
    cases().push_back({group, name, std::move(run)}); return true;
}
void check(bool value, const char* expression, int line) {
    if (!value) throw std::runtime_error("line " + std::to_string(line) + ": " + expression);
}
void near(double actual, double expected, double tolerance, int line) {
    if (!std::isfinite(actual) || std::abs(actual - expected) > tolerance)
        throw std::runtime_error("line " + std::to_string(line) + ": actual=" + std::to_string(actual) + ", expected=" + std::to_string(expected));
}
#define CHECK(expression) check(static_cast<bool>(expression), #expression, __LINE__)
#define NEAR(actual, expected, tolerance) near((actual), (expected), (tolerance), __LINE__)
#define TEST(group, name) void group##_##name(); const bool reg_##group##_##name = registerCase(#group, #name, group##_##name); void group##_##name()

FrameInput imageFrame(TimestampUs time, int gray = 100, bool target = true, double exposure = 1000) {
    FrameInput f;
    f.image = cv::Mat(10, 10, CV_8UC1, cv::Scalar(gray));
    f.roi.rectangles.emplace_back(0, 0, 10, 10);
    f.timestamp_us = time; f.actual_exposure_us = exposure; f.has_usable_target = target;
    return f;
}
struct Fixture {
    Config c;
    ExposureControl module;
    TimestampUs time = 0;
    PreCaptureResult last_pre;
    Fixture() {
        c.min_exposure_us = 100; c.max_exposure_us = 10000; c.empirical_exposure_us = 1000;
        c.metering.min_target_pixels = 1; c.metering.min_retained_pixels = 1;
        c.metering.trim_fraction_each_side = 0;
        c.detect_confirm_frames = 1;
        c.prediction.enabled = false;
        c.prediction.photometric_model_confirmed = true;
        c.prediction.nominal_interval_us = 1'000'000;
    }
    FrameResult send(FrameInput f) {
        time = f.timestamp_us;
        last_pre = module.preCapture(time, c);
        CHECK(last_pre.accepted);
        auto result = module.processFrame(f);
        CHECK(result.accepted);
        return result;
    }
    FrameResult at(TimestampUs t, int gray = 100, bool target = true, double exposure = 1000) {
        return send(imageFrame(t, gray, target, exposure));
    }
    FrameResult next(int gray = 100, bool target = true, double exposure = 1000) {
        return at(time + 1'000'000, gray, target, exposure);
    }
    void track(int gray = 118) {
        for (int i = 0; i < c.detect_confirm_frames; ++i) next(gray);
        CHECK(module.state() == State::TRACK);
    }
};

TEST(metering, rectangle_union_deduplicates_pixels) {
    Fixture x;
    auto f = imageFrame(0);
    f.image = (cv::Mat_<unsigned char>(1,4) << 10,100,30,200);
    f.roi.rectangles = {{0,0,2,1},{1,0,2,1}};
    const auto r = x.send(f);
    CHECK(r.metering.target.pixels == 3);
    NEAR(*r.metering.target.gray, 140.0/3, 1e-10);
    NEAR(*r.metering.global.gray, 85, 1e-10);
    CHECK(f.image.at<unsigned char>(0,1) == 100);
}
TEST(metering, disjoint_regions_do_not_use_enclosing_box) {
    Fixture x;
    auto f = imageFrame(0);
    f.image = (cv::Mat_<unsigned char>(1,4) << 10,100,30,200);
    f.roi.rectangles = {{0,0,1,1},{3,0,1,1}};
    const auto r = x.send(f);
    CHECK(r.metering.target.pixels == 2);
    NEAR(*r.metering.target.gray, 105, 1e-10);
}
TEST(metering, rotated_mask_and_rectangle_union) {
    Fixture x;
    auto f = imageFrame(0);
    f.image = cv::Mat(4,4,CV_8UC1,cv::Scalar(255));
    f.image.at<unsigned char>(1,1)=20; f.image.at<unsigned char>(2,2)=60; f.image.at<unsigned char>(0,3)=100;
    f.roi.rectangles = {{1,1,1,1}};
    f.roi.rotated_rectangles.emplace_back(cv::Point2f{2,2},cv::Size2f{3,1},45.0f);
    cv::Mat mask(4,4,CV_8UC1,cv::Scalar(0));
    mask.at<unsigned char>(2,2)=1; mask.at<unsigned char>(0,3)=128;
    f.roi.masks = {mask,mask};
    const auto r=x.send(f);
    CHECK(r.metering.target.pixels==3);
    NEAR(*r.metering.target.gray,60,1e-10);
}
TEST(metering, trim_removes_both_five_percent_tails) {
    Fixture x; x.c.metering.trim_fraction_each_side=.05;
    auto f=imageFrame(0); f.image=cv::Mat(1,20,CV_8UC1,cv::Scalar(100));
    f.image.at<unsigned char>(0,0)=0; f.image.at<unsigned char>(0,19)=255;
    f.roi.rectangles={{0,0,20,1}};
    const auto r=x.send(f);
    CHECK(r.metering.target.pixels==20 && r.metering.target.retained_pixels==18);
    NEAR(*r.metering.target.gray,100,1e-10);
    NEAR(*r.metering.global.gray,102.75,1e-10);
}
TEST(metering, clipping_empty_invalid_and_insufficient) {
    Fixture x; auto f=imageFrame(0); f.roi.rectangles={{-1,-1,2,2}};
    auto r=x.send(f); CHECK(r.metering.target.pixels==1);
    f.timestamp_us++; f.roi.rectangles={{50,50,1,1}};
    r=x.send(f); CHECK(r.metering.target.status==MeterStatus::EmptyRoi && !r.metering.target.gray);
    f.timestamp_us++; f.roi.rectangles.clear();
    r=x.send(f); CHECK(r.metering.target.status==MeterStatus::EmptyRoi);
    f.timestamp_us++; f.roi.rectangles={{0,0,-1,1}};
    r=x.send(f); CHECK(r.metering.target.status==MeterStatus::InvalidRoi);
    f.timestamp_us++; f.roi.rectangles={{0,0,10,10}}; f.roi.masks={cv::Mat(1,1,CV_8UC1)};
    r=x.send(f); CHECK(r.metering.target.status==MeterStatus::InvalidRoi);
    x.c.metering.min_target_pixels=101; f.timestamp_us++; f.roi.masks.clear();
    r=x.send(f); CHECK(r.metering.target.status==MeterStatus::InsufficientPixels);
    CHECK(!r.adjustment_suggested && !r.metering.target.gray);
}
TEST(metering, target_flag_and_real_zero_are_distinct) {
    Fixture x;
    auto r=x.next(0,false); CHECK(r.metering.target.status==MeterStatus::NoTarget && !r.metering.target.gray);
    CHECK(r.valid_history_count==0 && r.metering.global.valid());
    r=x.next(0,true); CHECK(r.metering.target.valid()); NEAR(*r.metering.target.gray,0,0);
    CHECK(r.valid_history_count==1);
}
TEST(metering, bgr_strides_and_fixed_central_global_region) {
    Fixture x;
    auto f=imageFrame(0); cv::Mat padded(6,6,CV_8UC3,cv::Scalar(255,0,0));
    f.image=padded(cv::Rect{1,1,4,4}); f.roi.rectangles={{0,0,4,4}};
    auto r=x.send(f); NEAR(*r.metering.target.gray,29,0);
    x.c.metering.global_center_fraction=.5;
    f=imageFrame(1); f.image.setTo(200); f.image(cv::Rect{2,2,5,5}).setTo(80);
    r=x.send(f); NEAR(*r.metering.global.gray,80,0); CHECK(r.metering.global.pixels==25);
}
TEST(metering, explicit_inset_and_unsupported_image) {
    const auto shrunk=inset(cv::Rect{0,0,10,10},.1); CHECK(shrunk==cv::Rect(1,1,8,8));
    Fixture x; auto f=imageFrame(0); f.roi.rectangles={{0,0,10,10}};
    CHECK(x.send(f).metering.target.pixels==100);
    f.timestamp_us++; f.image=cv::Mat(10,10,CV_16UC3,cv::Scalar(100,100,100));
    auto r=x.send(f); CHECK(r.metering.target.status==MeterStatus::UnsupportedImage && !r.adjustment_suggested);
    f.timestamp_us++; f.image.release(); r=x.send(f); CHECK(r.metering.global.status==MeterStatus::EmptyImage);
}
TEST(metering, retained_sample_limit_and_extreme_coordinates) {
    Fixture x; x.c.metering.trim_fraction_each_side=.05; x.c.metering.min_retained_pixels=100;
    auto f=imageFrame(0); auto r=x.send(f);
    CHECK(r.metering.target.retained_pixels==90 && r.metering.target.status==MeterStatus::InsufficientPixels);
    f.timestamp_us++; f.roi.rectangles={{std::numeric_limits<int>::max(),0,std::numeric_limits<int>::max(),1}};
    r=x.send(f); CHECK(r.metering.target.status==MeterStatus::EmptyRoi);
    f.timestamp_us++; f.roi.rectangles.clear();
    f.roi.rotated_rectangles.emplace_back(cv::Point2f{2,2},cv::Size2f{3,1},std::numeric_limits<float>::quiet_NaN());
    r=x.send(f); CHECK(r.metering.target.status==MeterStatus::InvalidRoi);
}

TEST(stateless, ordinary_and_trimmed_means_share_known_samples) {
    cv::Mat image(1,20,CV_8UC1,cv::Scalar(100));
    image.at<unsigned char>(0,0)=0; image.at<unsigned char>(0,19)=255;
    Roi roi; roi.rectangles={{0,0,20,1}};
    const auto r=measureImage(image,roi,true);
    CHECK(r.target.valid() && r.global.valid());
    CHECK(r.target.pixels==20 && r.target.retained_pixels==18);
    NEAR(*r.target.arithmetic_gray,102.75,0);
    NEAR(*r.target.gray,100,0);
    NEAR(*r.global.arithmetic_gray,102.75,0);
    NEAR(*r.global.gray,102.75,0);
    NEAR(r.target.near_black_fraction,.05,0);
    NEAR(r.target.saturated_fraction,.05,0);
    CHECK(image.at<unsigned char>(0,0)==0 && image.at<unsigned char>(0,19)==255);
}
TEST(stateless, roi_union_mixed_shapes_and_masks) {
    MeteringConfig c; c.min_target_pixels=1; c.min_retained_pixels=1;
    cv::Mat image(4,4,CV_8UC1,cv::Scalar(255));
    image.at<unsigned char>(1,1)=20; image.at<unsigned char>(2,2)=60; image.at<unsigned char>(0,3)=100;
    Roi roi; roi.rectangles={{1,1,1,1},{1,1,1,1}};
    roi.rotated_rectangles.emplace_back(cv::Point2f{2,2},cv::Size2f{3,1},45.0f);
    cv::Mat mask(4,4,CV_8UC1,cv::Scalar(0));
    mask.at<unsigned char>(2,2)=1; mask.at<unsigned char>(0,3)=128;
    roi.masks={mask,mask};
    const auto r=measureImage(image,roi,true,c);
    CHECK(r.target.pixels==3 && r.target.valid());
    NEAR(*r.target.arithmetic_gray,60,0); NEAR(*r.target.gray,60,0);
    NEAR(*r.global.arithmetic_gray,(180.0+13*255)/16,0);
    CHECK(cv::countNonZero(mask)==2 && mask.at<unsigned char>(0,3)==128);
}
TEST(stateless, absent_region_is_distinct_from_black_and_saturated) {
    cv::Mat image(8,8,CV_8UC1,cv::Scalar(0)); Roi roi; roi.rectangles={{0,0,8,8}};
    auto r=measureImage(image,roi,false);
    CHECK(r.target.status==MeterStatus::NoTarget && !r.target.arithmetic_gray);
    CHECK(r.global.valid()); NEAR(*r.global.arithmetic_gray,0,0);
    r=measureImage(image,roi,true);
    CHECK(r.target.valid()); NEAR(*r.target.arithmetic_gray,0,0);
    NEAR(r.target.near_black_fraction,1,0);
    image.setTo(255); r=measureImage(image,roi,true);
    CHECK(r.target.valid()); NEAR(*r.target.arithmetic_gray,255,0);
    NEAR(r.target.saturated_fraction,1,0);
}
TEST(stateless, invalid_roi_and_images_keep_explicit_missing_values) {
    const cv::Mat image(8,8,CV_8UC1,cv::Scalar(90)); Roi roi;
    auto r=measureImage(image,roi,true);
    CHECK(r.target.status==MeterStatus::EmptyRoi && !r.target.arithmetic_gray && r.global.valid());
    roi.rectangles={{0,0,1,1}}; r=measureImage(image,roi,true);
    CHECK(r.target.status==MeterStatus::InsufficientPixels && !r.target.arithmetic_gray);
    roi.rectangles={{0,0,-1,1}}; r=measureImage(image,roi,true);
    CHECK(r.target.status==MeterStatus::InvalidRoi && r.global.valid());
    roi.rectangles.clear(); roi.masks={cv::Mat(1,1,CV_8UC1,cv::Scalar(1))};
    r=measureImage(image,roi,true); CHECK(r.target.status==MeterStatus::InvalidRoi && !r.target.arithmetic_gray);
    roi.masks={cv::Mat(8,8,CV_32FC1,cv::Scalar(1))};
    CHECK(measureImage(image,roi,true).target.status==MeterStatus::InvalidRoi);
    roi.masks.clear(); roi.rotated_rectangles.emplace_back(cv::Point2f{2,2},cv::Size2f{2,2},std::numeric_limits<float>::infinity());
    CHECK(measureImage(image,roi,true).target.status==MeterStatus::InvalidRoi);
    r=measureImage({},roi,true);
    CHECK(r.global.status==MeterStatus::EmptyImage && !r.global.arithmetic_gray);
    r=measureImage(cv::Mat(8,8,CV_16UC3),roi,true);
    CHECK(r.global.status==MeterStatus::UnsupportedImage && !r.global.arithmetic_gray);
    const int sizes[]={2,2,2};
    r=measureImage(cv::Mat(3,sizes,CV_8UC1,cv::Scalar(20)),roi,true);
    CHECK(r.global.status==MeterStatus::UnsupportedImage);
}
TEST(stateless, invalid_config_is_rejected_before_image_or_roi_access) {
    const std::vector<std::function<void(MeteringConfig&)>> corrupt={
        [](MeteringConfig& c){c.trim_fraction_each_side=-.1;},
        [](MeteringConfig& c){c.trim_fraction_each_side=.5;},
        [](MeteringConfig& c){c.trim_fraction_each_side=std::numeric_limits<double>::quiet_NaN();},
        [](MeteringConfig& c){c.min_target_pixels=0;},
        [](MeteringConfig& c){c.min_retained_pixels=0;},
        [](MeteringConfig& c){c.global_center_fraction=0;},
        [](MeteringConfig& c){c.global_center_fraction=1.1;},
        [](MeteringConfig& c){c.global_center_fraction=std::numeric_limits<double>::infinity();},
        [](MeteringConfig& c){c.near_black_level=-1;},
        [](MeteringConfig& c){c.saturation_level=256;},
        [](MeteringConfig& c){c.saturation_level=c.near_black_level;}
    };
    for(const auto& mutate:corrupt) {
        MeteringConfig c; mutate(c);
        const auto r=measureImage({}, {}, false, c);
        CHECK(r.target.status==MeterStatus::InvalidConfiguration && r.global.status==MeterStatus::InvalidConfiguration);
        CHECK(!r.target.gray && !r.target.arithmetic_gray && !r.global.arithmetic_gray);
        Fixture x; x.c.metering=c; CHECK(!validate(x.c).empty());
    }
    CHECK(std::string(toString(MeterStatus::InvalidConfiguration))=="InvalidConfiguration");
}
TEST(stateless, bgr_strides_and_global_center_are_supported_without_controller) {
    cv::Mat padded(6,6,CV_8UC3,cv::Scalar(255,0,0));
    const cv::Mat image=padded(cv::Rect{1,1,4,4}); Roi roi; roi.rectangles={{0,0,4,4}};
    auto r=measureImage(image,roi,true);
    CHECK(r.target.valid()); NEAR(*r.target.arithmetic_gray,29,0);
    cv::Mat gray(10,10,CV_8UC1,cv::Scalar(200)); gray(cv::Rect{2,2,5,5}).setTo(80);
    MeteringConfig c; c.global_center_fraction=.5;
    r=measureImage(gray,{},false,c);
    CHECK(r.global.pixels==25); NEAR(*r.global.arithmetic_gray,80,0);
}
TEST(stateless, repeats_are_deterministic_and_leave_controller_trajectory_unchanged) {
    Fixture a,b; a.track(); b.track();
    const auto frame=imageFrame(a.time+1'000'000,80);
    const auto first=measureImage(frame.image,frame.roi,true,a.c.metering);
    const auto history=a.module.history(); const auto state=a.module.state();
    for(int i=0;i<8;++i) {
        const auto r=measureImage(frame.image,frame.roi,true,a.c.metering);
        CHECK(r.target.pixels==first.target.pixels && r.target.gray==first.target.gray &&
              r.target.arithmetic_gray==first.target.arithmetic_gray && r.global.gray==first.global.gray);
        measureImage(frame.image,{},false);
    }
    CHECK(a.module.state()==state && a.module.history().size()==history.size());
    CHECK(a.module.history().back().timestamp_us==history.back().timestamp_us);
    for(int i=0;i<3;++i) {
        const auto actual=a.next(80), control=b.next(80);
        CHECK(actual.state==control.state && actual.reason==control.reason &&
              actual.suggested_exposure_us==control.suggested_exposure_us &&
              actual.control.integral==control.control.integral &&
              actual.control.same_direction_count==control.control.same_direction_count &&
              actual.valid_history_count==control.valid_history_count);
        CHECK(actual.metering.target.gray==first.target.gray &&
              actual.metering.target.arithmetic_gray==first.target.arithmetic_gray);
    }
}

TEST(stateless, gray16_preserves_source_precision_and_normalizes_after_statistics) {
    MeteringConfig c; c.min_target_pixels=1; c.min_retained_pixels=1; c.trim_fraction_each_side=.25;
    // 1000 and 1001 must not be rounded to the same 8-bit intensity before averaging.
    const cv::Mat image=(cv::Mat_<unsigned short>(1,4)<<0,1000,1001,65535);
    Roi roi; roi.rectangles={{0,0,4,1}};
    const auto r=measureImage(image,roi,true,c);
    CHECK(r.target.valid() && r.global.valid());
    CHECK(r.target.source_bit_depth==16 && r.global.source_max_gray==65535.0);
    NEAR(*r.target.source_arithmetic_gray,16884.0,0);
    NEAR(*r.global.source_arithmetic_gray,16884.0,0);
    NEAR(*r.target.arithmetic_gray,16884.0*255/65535,1e-12);
    NEAR(*r.target.gray,1000.5*255/65535,1e-12);
    CHECK(r.target.retained_pixels==2 && r.target.pixels==4);
    NEAR(r.target.near_black_fraction,.25,0);
    NEAR(r.target.saturated_fraction,.25,0);
    CHECK(image.at<unsigned short>(0,2)==1001);
}
TEST(stateless, gray16_threshold_boundaries_black_saturation_and_stride) {
    MeteringConfig c; c.min_target_pixels=1; c.min_retained_pixels=1; c.trim_fraction_each_side=0;
    cv::Mat padded(4,8,CV_16UC1,cv::Scalar(9999));
    cv::Mat image=padded(cv::Rect{1,1,6,2});
    const unsigned short samples[]={0,514,515,65020,65021,65535};
    for(int y=0;y<image.rows;++y) for(int x=0;x<image.cols;++x) image.at<unsigned short>(y,x)=samples[x];
    Roi roi; roi.rectangles={{0,0,6,2}};
    const auto r=measureImage(image,roi,true,c);
    NEAR(r.target.near_black_fraction,1.0/3,0);
    NEAR(r.target.saturated_fraction,1.0/3,0);
    NEAR(*r.target.source_arithmetic_gray,196605.0/6,0);
    CHECK(padded.at<unsigned short>(0,0)==9999 && !image.isContinuous());
    image.setTo(0); const auto black=measureImage(image,{},false);
    CHECK(black.target.status==MeterStatus::NoTarget && black.target.source_bit_depth==16);
    NEAR(*black.global.source_arithmetic_gray,0,0); NEAR(black.global.near_black_fraction,1,0);
    image.setTo(65535); const auto bright=measureImage(image,roi,true,c);
    NEAR(*bright.target.gray,255,0); NEAR(*bright.target.source_arithmetic_gray,65535,0);
    NEAR(bright.target.saturated_fraction,1,0);
}
TEST(stateless, valid_image_mask_intersects_union_and_global_without_mutation) {
    MeteringConfig c; c.min_target_pixels=1; c.min_retained_pixels=1; c.trim_fraction_each_side=0;
    const cv::Mat image8=(cv::Mat_<unsigned char>(2,4)<<0,10,20,30,40,50,60,255);
    const cv::Mat valid=(cv::Mat_<unsigned char>(2,4)<<0,1,128,0,2,255,0,0);
    Roi roi; roi.rectangles={{0,0,2,2},{1,0,2,1}};
    roi.rotated_rectangles.emplace_back(cv::Point2f{2,1},cv::Size2f{2,2},0.0f);
    cv::Mat part(2,4,CV_8UC1,cv::Scalar(0)); part.at<unsigned char>(1,1)=1; roi.masks={part,part};
    for(int depth : {CV_8U,CV_16U}) {
        cv::Mat image; image8.convertTo(image,depth,depth==CV_16U?257:1);
        const auto r=measureImage(image,roi,true,c,valid);
        CHECK(r.global.pixels==4 && r.target.pixels==4);
        NEAR(*r.global.arithmetic_gray,30,1e-12); NEAR(*r.target.arithmetic_gray,30,1e-12);
        NEAR(*r.target.source_arithmetic_gray,depth==CV_16U?7710:30,0);
        CHECK(cv::countNonZero(valid)==4 && valid.at<unsigned char>(0,2)==128);
        CHECK(cv::countNonZero(part)==1 && part.at<unsigned char>(1,1)==1);
        CHECK(image8.at<unsigned char>(1,3)==255);
        const auto repeat=measureImage(image,roi,true,c,valid);
        CHECK(repeat.target.source_arithmetic_gray==r.target.source_arithmetic_gray);
    }
}
TEST(stateless, valid_image_mask_keeps_target_independent_of_global_center) {
    MeteringConfig c; c.min_target_pixels=1; c.min_retained_pixels=1; c.global_center_fraction=.5;
    cv::Mat image(4,4,CV_8UC1,cv::Scalar(200));
    image.at<unsigned char>(1,1)=20; image.at<unsigned char>(0,0)=80;
    cv::Mat valid(4,4,CV_8UC1,cv::Scalar(0)); valid.at<unsigned char>(1,1)=1; valid.at<unsigned char>(0,0)=1;
    Roi roi; roi.rectangles={{0,0,1,1}};
    const auto r=measureImage(image,roi,true,c,valid);
    CHECK(r.global.pixels==1 && r.target.pixels==1);
    NEAR(*r.global.arithmetic_gray,20,0); NEAR(*r.target.arithmetic_gray,80,0);
    CHECK(r.target.source_bit_depth==8 && r.target.source_max_gray==255.0);
}
TEST(stateless, invalid_valid_image_masks_and_empty_intersections_are_explicit) {
    const cv::Mat image(8,8,CV_16UC1,cv::Scalar(1001)); Roi roi; roi.rectangles={{0,0,4,8}};
    const int sizes[]={2,4,8};
    const std::vector<cv::Mat> invalid={cv::Mat(7,8,CV_8UC1,cv::Scalar(1)),
        cv::Mat(8,8,CV_16UC1,cv::Scalar(1)),cv::Mat(8,8,CV_8UC3,cv::Scalar(1,1,1)),
        cv::Mat(3,sizes,CV_8UC1,cv::Scalar(1))};
    for(const auto& mask:invalid) {
        const auto r=measureImage(image,roi,true,{},mask);
        CHECK(r.target.status==MeterStatus::InvalidRoi && r.global.status==MeterStatus::InvalidRoi);
        CHECK(!r.target.arithmetic_gray && !r.global.source_arithmetic_gray);
        const auto noTarget=measureImage(image,{},false,{},mask);
        CHECK(noTarget.target.status==MeterStatus::NoTarget && noTarget.global.status==MeterStatus::InvalidRoi);
    }
    cv::Mat valid(8,8,CV_8UC1,cv::Scalar(0));
    auto r=measureImage(image,roi,true,{},valid);
    CHECK(r.global.status==MeterStatus::EmptyRoi && r.target.status==MeterStatus::EmptyRoi);
    CHECK(!r.global.source_arithmetic_gray && r.global.pixels==0 && r.global.source_bit_depth==16);
    valid(cv::Rect{4,0,4,8}).setTo(255); r=measureImage(image,roi,true,{},valid);
    CHECK(r.global.valid() && r.target.status==MeterStatus::EmptyRoi);
    NEAR(*r.global.source_arithmetic_gray,1001,0);
    valid.setTo(0); valid.at<unsigned char>(0,0)=1; r=measureImage(image,roi,true,{},valid);
    CHECK(r.global.valid() && r.target.status==MeterStatus::InsufficientPixels);
    CHECK(!r.target.source_arithmetic_gray && !r.target.arithmetic_gray);
    const auto defaultMask=measureImage(image,roi,true);
    const auto explicitEmptyMask=measureImage(image,roi,true,{},{});
    CHECK(defaultMask.global.pixels==64 && defaultMask.global.source_arithmetic_gray==explicitEmptyMask.global.source_arithmetic_gray);
}
TEST(stateless, gray16_and_gray8_equivalent_scale_preserves_control_trajectory) {
    Fixture a,b;
    for(int gray : {118,80,40,200,118}) {
        auto frame8=imageFrame(a.time+1'000'000,gray);
        auto frame16=frame8;
        frame8.image.convertTo(frame16.image,CV_16U,257);
        const auto r8=a.send(frame8), r16=b.send(frame16);
        CHECK(r8.state==r16.state && r8.reason==r16.reason);
        NEAR(*r8.metering.target.gray,*r16.metering.target.gray,1e-12);
        CHECK(r8.adjustment_suggested==r16.adjustment_suggested);
        if(r8.suggested_exposure_us) NEAR(*r8.suggested_exposure_us,*r16.suggested_exposure_us,1e-10);
    }
}

TEST(history, window_inclusive_boundary_and_filtering) {
    Fixture x; x.c.history_window_us=3'000'000; x.c.idle_timeout_us=100'000'000;
    x.at(0); x.at(1'000'000); x.at(3'000'000);
    auto r=x.at(4'000'000); CHECK(r.valid_history_count==3);
    CHECK(x.module.history().front().timestamp_us==1'000'000);
    r=x.at(4'000'001,0); // zero gray is still a real valid target
    CHECK(x.module.history().front().timestamp_us==3'000'000);
}
TEST(history, five_points_are_not_silently_replaced_by_three) {
    Fixture x; x.c.prediction.enabled=true; x.c.prediction.points=5;
    for(int i=0;i<4;++i) CHECK(!x.next(90+5*i).prediction.available);
    const auto r=x.next(110); CHECK(r.prediction.available && r.prediction.points_used==5);
    NEAR(*r.prediction.predicted_gray,115,1e-9);
}
TEST(history, invalid_frames_do_not_evict_recent_valid_targets) {
    Fixture x; x.c.prediction.enabled=true; x.c.history_capacity=3;
    x.next(); x.next(); x.next();
    for(int i=0;i<10;++i) x.next(30,false);
    const auto r=x.next(100,true);
    CHECK(r.valid_history_count==3 && r.prediction.available);
    CHECK(x.module.history().size()==3);
    NEAR(*r.prediction.predicted_gray,100,1e-9);
}
TEST(history, actual_exposure_normalization_with_black_offset) {
    Fixture x; x.c.prediction.enabled=true; x.c.prediction.black_level=10;
    x.at(0,50,true,400); x.at(1'000'000,90,true,800);
    const auto r=x.at(4'000'000,170,true,1600);
    CHECK(r.prediction.available);
    NEAR(*r.prediction.normalized_slope_per_second,0,1e-12);
    NEAR(*r.prediction.predicted_gray,170,1e-9);
    NEAR(x.module.history().back().actual_exposure_us,1600,0);
}

TEST(prediction, unequal_time_intervals_and_explicit_horizon) {
    Fixture x; x.c.prediction.enabled=true;
    x.at(0,100); x.at(1'000'000,110);
    auto f=imageFrame(4'000'000,140); f.next_capture_timestamp_us=6'000'000;
    const auto r=x.send(f); CHECK(r.prediction.available && r.prediction.adopted);
    NEAR(*r.prediction.normalized_slope_per_second,.01,1e-12);
    NEAR(*r.prediction.predicted_gray,160,1e-9);
}
TEST(prediction, large_timestamp_epoch_does_not_change_fit) {
    Fixture x; x.c.prediction.enabled=true;
    const TimestampUs epoch=1'800'000'000'000'000;
    x.at(epoch,100); x.at(epoch+1'000'000,110);
    auto f=imageFrame(epoch+4'000'000,140); f.next_capture_timestamp_us=epoch+6'000'000;
    const auto r=x.send(f); CHECK(r.prediction.available);
    NEAR(*r.prediction.predicted_gray,160,1e-9);
}
FrameResult trendResult(bool rising, bool enabled) {
    Fixture x; x.c.prediction.enabled=enabled; x.c.controller.ki=0; x.c.controller.same_direction_frames=1;
    x.at(0,rising?80:120); x.at(1'000'000,rising?90:110);
    return x.at(2'000'000,100);
}
TEST(prediction, history_changes_exposure_and_is_not_double_compensated) {
    const auto rise=trendResult(true,true), fall=trendResult(false,true);
    CHECK(rise.prediction.adopted && fall.prediction.adopted);
    NEAR(*rise.prediction.predicted_gray,110,1e-9);
    NEAR(*fall.prediction.predicted_gray,90,1e-9);
    CHECK(!rise.adjustment_suggested && fall.adjustment_suggested);
    NEAR(*rise.suggested_exposure_us,1000,1e-9);
    NEAR(*fall.suggested_exposure_us,1000*(1+.4*(118-90)/118.0),1e-9);
    const auto no_rise=trendResult(true,false), no_fall=trendResult(false,false);
    NEAR(*no_rise.suggested_exposure_us,*no_fall.suggested_exposure_us,1e-9);
    NEAR(*no_fall.suggested_exposure_us,1000*(1+.4*(118-100)/118.0),1e-9);
}
TEST(prediction, insufficient_missing_horizon_and_model_fallback) {
    Fixture x; x.c.prediction.enabled=true; x.c.prediction.nominal_interval_us=0;
    CHECK(x.next(100).prediction.reason==PredictionReason::InsufficientHistory);
    x.next(100); auto r=x.next(100); CHECK(r.prediction.reason==PredictionReason::MissingHorizon);
    CHECK(!r.prediction.adopted && r.control.control_error_ratio.has_value());
    x.c.prediction.photometric_model_confirmed=false;
    r=x.next(100); CHECK(r.prediction.reason==PredictionReason::ModelNotConfirmed);
}
TEST(prediction, reject_clipping_bad_fit_and_excessive_horizon) {
    Fixture x; x.c.prediction.enabled=true;
    x.next(100); x.next(100); auto r=x.next(255);
    CHECK(r.prediction.reason==PredictionReason::DarkOrSaturated && !r.prediction.adopted);
    Fixture y; y.c.prediction.enabled=true; y.c.prediction.max_relative_fit_rmse=.01;
    y.next(100); y.next(200); r=y.next(100);
    CHECK(r.prediction.reason==PredictionReason::ResidualTooLarge && !r.prediction.adopted);
    auto f=imageFrame(y.time+1'000'000,100); f.next_capture_timestamp_us=f.timestamp_us+61'000'000;
    r=y.send(f); CHECK(r.prediction.reason==PredictionReason::InvalidHorizon);
    Fixture z; z.c.prediction.enabled=true;
    z.next(10); z.next(100); r=z.next(190);
    CHECK(r.prediction.reason==PredictionReason::OutOfRange && !r.prediction.adopted);
}

TEST(controller, large_error_is_immediate_but_step_limited) {
    Fixture x; x.track(); const auto r=x.next(40);
    CHECK(r.reason==Reason::ProportionalAdjustment && r.adjustment_suggested);
    NEAR(*r.suggested_exposure_us,1250,1e-9);
    CHECK(r.control.step_limited && r.control.same_direction_count==1);
    NEAR(r.control.integral,0,0);
}
TEST(controller, small_error_confirmation_pi_and_integral_limit) {
    Fixture x; x.c.controller.target_gray=100; x.c.controller.integral_abs_limit=.3; x.track(100);
    auto r=x.next(80); CHECK(r.reason==Reason::ConfirmingError); NEAR(r.control.integral,0,0);
    r=x.next(80); NEAR(r.control.integral,.2,1e-12); NEAR(*r.suggested_exposure_us,1100,1e-9);
    r=x.next(80); NEAR(r.control.integral,.3,1e-12); NEAR(*r.suggested_exposure_us,1110,1e-9);
    r=x.next(80); NEAR(r.control.integral,.3,1e-12);
    r=x.next(100); CHECK(r.reason==Reason::Deadband); NEAR(r.control.integral,0,0);
    r=x.next(100,false); NEAR(r.control.integral,0,0);
}
TEST(controller, hysteresis_boundary_and_active_band) {
    Fixture x; x.c.controller.target_gray=100; x.c.controller.same_direction_frames=1; x.track(100);
    CHECK(x.next(89).reason==Reason::Hysteresis);
    CHECK(x.next(88).adjustment_suggested);
    CHECK(x.next(89).adjustment_suggested);
    CHECK(x.next(91).reason==Reason::Deadband);
    CHECK(x.next(89).reason==Reason::Hysteresis);
}
TEST(controller, opposite_direction_requires_new_confirmation) {
    Fixture x; x.c.controller.target_gray=100; x.track(100);
    CHECK(!x.next(80).adjustment_suggested);
    auto r=x.next(120); CHECK(!r.adjustment_suggested && r.control.same_direction_count==1);
    r=x.next(120); CHECK(r.adjustment_suggested && *r.suggested_exposure_us<1000);
}
TEST(controller, exposure_limits_and_step_limits_block_windup) {
    Fixture x; x.c.controller.target_gray=100; x.c.controller.same_direction_frames=1;
    x.c.max_exposure_us=1100; x.track(100);
    auto r=x.next(80,true,1090); NEAR(*r.suggested_exposure_us,1100,1e-9);
    CHECK(r.control.integral_blocked_by_limit && r.control.exposure_limited); NEAR(r.control.integral,0,0);
    r=x.next(80,true,1100); CHECK(!r.adjustment_suggested && r.reason==Reason::ExposureLimit);
    NEAR(r.control.integral,0,0);
    Fixture y; y.c.controller.target_gray=100; y.c.controller.same_direction_frames=1;
    y.c.controller.kp=1; y.c.controller.ki=1; y.track(100);
    r=y.next(70); CHECK(r.control.integral_blocked_by_limit && r.control.step_limited); NEAR(r.control.integral,0,0);
    NEAR(*r.suggested_exposure_us,1250,1e-9);
    Fixture z; z.c.min_exposure_us=900; z.c.controller.target_gray=100; z.c.controller.same_direction_frames=1; z.track(100);
    r=z.next(130,true,900); CHECK(!r.adjustment_suggested && r.control.integral_blocked_by_limit);
}
TEST(controller, track_ignores_global_background) {
    const auto calculate=[](int background) {
        Fixture x; x.c.controller.same_direction_frames=1; x.track();
        auto f=imageFrame(x.time+1'000'000,background); f.roi.rectangles={{4,4,2,2}};
        f.image(cv::Rect{4,4,2,2}).setTo(80); return x.send(f);
    };
    const auto a=calculate(0), b=calculate(240);
    CHECK(*a.metering.global.gray!=*b.metering.global.gray);
    NEAR(*a.suggested_exposure_us,*b.suggested_exposure_us,0);
}

TEST(states, capture_track_lost_freeze_and_capture) {
    Fixture x; x.c.detect_confirm_frames=3;
    CHECK(x.next().state==State::CAPTURE); CHECK(x.next().state==State::CAPTURE);
    auto r=x.next(); CHECK(r.state==State::TRACK && !r.adjustment_suggested);
    CHECK(x.next(30,false).state==State::TRACK); CHECK(x.next(30,false).state==State::TRACK);
    r=x.next(30,false); CHECK(r.state==State::LOST && r.freeze_remaining==2);
    r=x.next(30,false); CHECK(r.state==State::LOST && r.freeze_remaining==1);
    r=x.next(30,false); CHECK(r.state==State::CAPTURE && r.freeze_remaining==0 && !r.adjustment_suggested);
}
TEST(states, short_loss_and_reacquisition_keep_exposure_and_history) {
    Fixture x; x.c.detect_confirm_frames=3; x.track();
    auto r=x.next(50,false,2345); CHECK(r.state==State::TRACK && !x.last_pre.initialization_required);
    NEAR(*r.suggested_exposure_us,2345,0); CHECK(r.valid_history_count==3);
    x.next(50,false); x.next(50,false); CHECK(x.module.state()==State::LOST);
    CHECK(x.next(100).state==State::LOST); CHECK(x.next(100).state==State::LOST);
    r=x.next(100); CHECK(r.state==State::TRACK && r.reason==Reason::TrackingActivated);
    CHECK(!x.last_pre.initialization_required && r.valid_history_count==6);
}
TEST(states, bad_roi_is_not_a_detection_failure) {
    Fixture x; x.track(); auto f=imageFrame(x.time+1'000'000); f.roi.rectangles.clear();
    const auto r=x.send(f); CHECK(r.state==State::TRACK && r.loss_count==0);
    CHECK(r.reason==Reason::InvalidMetering && !r.adjustment_suggested);
}
TEST(states, freeze_counts_new_frames_even_with_intermittent_detections) {
    Fixture x; x.c.detect_confirm_frames=3; x.track();
    x.next(20,false); x.next(20,false); x.next(20,false);
    const auto r=x.next(100,true); CHECK(r.state==State::LOST && r.freeze_remaining==1);
    CHECK(x.next(20,false).state==State::CAPTURE);
}

FrameResult missingWithPermission(Fixture& x,int gray=20) {
    auto f=imageFrame(x.time+1'000'000,gray,false); f.allow_no_target_recovery=true; return x.send(f);
}
TEST(recovery, default_denial_and_single_recovery_per_episode) {
    Fixture x; x.c.detect_confirm_frames=3; x.c.recovery.global_reference_gray=100;
    auto r=x.next(20,false); CHECK(r.reason==Reason::RecoveryNotAllowed && !r.recovery_used);
    r=missingWithPermission(x); CHECK(r.reason==Reason::RecoverySuggested && r.recovery_used);
    NEAR(*r.suggested_exposure_us,1100,1e-9);
    for(int i=0;i<10;++i) { r=missingWithPermission(x); CHECK(!r.adjustment_suggested && r.reason==Reason::NotRecovered); }
    x.next(100,true); x.next(100,true); r=missingWithPermission(x);
    CHECK(r.recovery_used && !r.adjustment_suggested);
    x.next(100,true); x.next(100,true); r=x.next(100,true); CHECK(!r.recovery_used && !r.loss_episode_active);
}
TEST(recovery, freeze_finishes_before_recovery_and_no_scanning) {
    Fixture x; x.c.recovery.global_reference_gray=100; x.track();
    for(int i=0;i<3;++i) CHECK(!missingWithPermission(x).adjustment_suggested);
    CHECK(x.module.state()==State::LOST);
    for(int i=0;i<2;++i) CHECK(!missingWithPermission(x).adjustment_suggested);
    CHECK(x.module.state()==State::CAPTURE);
    CHECK(missingWithPermission(x).reason==Reason::RecoverySuggested);
    CHECK(missingWithPermission(x).reason==Reason::NotRecovered);
}
TEST(recovery, automatic_initialization_and_manual_reset_do_not_rearm) {
    Fixture x; x.c.detect_confirm_frames=3; x.c.recovery.global_reference_gray=100;
    CHECK(missingWithPermission(x).recovery_used);
    x.c.revision++; auto r=missingWithPermission(x);
    CHECK(x.last_pre.initialization_required && r.recovery_used && !r.adjustment_suggested);
    x.module.reset(ResetReason::Manual); r=missingWithPermission(x);
    CHECK(r.recovery_used && !r.adjustment_suggested);
    auto pre=x.module.preCapture(x.time+86'400'000'000LL,x.c);
    CHECK(pre.initialization_required);
    x.time+=86'400'000'000LL; r=missingWithPermission(x); CHECK(r.recovery_used && !r.adjustment_suggested);
    x.module.reset(ResetReason::NewBusinessCycle); r=missingWithPermission(x);
    CHECK(r.reason==Reason::RecoverySuggested);
}
TEST(recovery, missing_reference_normal_global_invalid_frame_and_limit) {
    Fixture x; auto r=missingWithPermission(x); CHECK(r.reason==Reason::RecoveryReferenceMissing && !r.recovery_used);
    x.c.recovery.global_reference_gray=100;
    r=missingWithPermission(x,100); CHECK(r.reason==Reason::RecoveryNotNeeded && !r.recovery_used);
    auto f=imageFrame(x.time+1'000'000,20,false); f.allow_no_target_recovery=true; f.image.release();
    r=x.send(f); CHECK(r.reason==Reason::InvalidMetering && !r.recovery_used);
    f=imageFrame(x.time+1'000'000,20,false,x.c.max_exposure_us); f.allow_no_target_recovery=true;
    r=x.send(f); CHECK(r.reason==Reason::ExposureLimit && r.recovery_used && !r.adjustment_suggested);
    CHECK(missingWithPermission(x).reason==Reason::NotRecovered);
}
TEST(recovery, history_expiry_cannot_refresh_consumed_opportunity) {
    Fixture x; x.c.recovery.global_reference_gray=100; x.c.history_window_us=10'000'000;
    x.c.idle_timeout_us=100'000'000; x.track();
    for(int i=0;i<5;++i) missingWithPermission(x);
    CHECK(missingWithPermission(x).reason==Reason::RecoverySuggested);
    int initializations=0;
    for(int i=0;i<20;++i) {
        const auto r=missingWithPermission(x);
        if(x.last_pre.initialization_required) {
            ++initializations; CHECK(x.last_pre.initialization_reason==ResetReason::HistoryExpired);
        }
        CHECK(r.recovery_used && !r.adjustment_suggested);
    }
    CHECK(initializations==1);
}

TEST(lifecycle, first_start_and_repeated_prechecks_initialize_once) {
    Fixture x;
    auto p=x.module.preCapture(0,x.c); CHECK(p.accepted && p.initialization_required && p.initialization_reason==ResetReason::Startup);
    NEAR(*p.suggested_exposure_us,1000,0);
    CHECK(!x.module.preCapture(0,x.c).initialization_required);
    CHECK(!x.module.preCapture(900'000'000,x.c).initialization_required);
}
TEST(lifecycle, overnight_checks_before_capture_once) {
    Fixture x; x.track();
    const auto overnight=x.time+86'400'000'000LL;
    auto p=x.module.preCapture(overnight,x.c);
    CHECK(p.initialization_required && p.initialization_reason==ResetReason::IdleTimeout && p.state==State::CAPTURE);
    CHECK(x.module.history().empty());
    CHECK(!x.module.preCapture(overnight,x.c).initialization_required);
    CHECK(!x.module.preCapture(overnight+1,x.c).initialization_required);
}
TEST(lifecycle, history_expiry_during_active_missing_frames_is_one_shot) {
    Fixture x; x.c.history_window_us=5'000'000; x.c.idle_timeout_us=100'000'000;
    x.at(0); x.at(2'000'000,20,false); x.at(4'000'000,20,false);
    auto p=x.module.preCapture(6'000'000,x.c);
    CHECK(p.initialization_required && p.initialization_reason==ResetReason::HistoryExpired);
    CHECK(!x.module.preCapture(6'000'000,x.c).initialization_required);
    CHECK(x.module.processFrame(imageFrame(6'000'000,20,false)).accepted);
    for(TimestampUs t=8'000'000;t<30'000'000;t+=2'000'000) {
        x.at(t,20,false); CHECK(!x.last_pre.initialization_required);
    }
}
TEST(lifecycle, continuous_no_target_does_not_repeat_initialization) {
    Fixture x;
    for(int i=0;i<610;++i) {
        x.at(static_cast<TimestampUs>(i)*1'000'000,20,false);
        CHECK(x.last_pre.initialization_required==(i==0));
    }
}
TEST(lifecycle, changed_values_or_revision_initialize_once) {
    Fixture x; x.track(); x.c.controller.kp=.3;
    auto p=x.module.preCapture(x.time+1,x.c); CHECK(p.initialization_reason==ResetReason::ConfigurationChanged);
    CHECK(!x.module.preCapture(x.time+1,x.c).initialization_required);
    x.c.revision++; p=x.module.preCapture(x.time+1,x.c); CHECK(p.initialization_required);
    CHECK(!x.module.preCapture(x.time+1,x.c).initialization_required);
}
TEST(lifecycle, missing_or_stale_precheck_is_rejected) {
    Fixture x;
    CHECK(x.module.processFrame(imageFrame(0)).reason==Reason::PreCaptureRequired);
    x.track();
    auto r=x.module.processFrame(imageFrame(x.time+1'000'000)); CHECK(!r.accepted && r.reason==Reason::PreCaptureRequired);
    CHECK(x.module.preCapture(x.time+1,x.c).accepted);
    r=x.module.processFrame(imageFrame(x.time+301'000'000)); CHECK(!r.accepted && r.reason==Reason::PreCaptureRequired);
}

TEST(feedback, duplicates_and_out_of_order_do_not_mutate) {
    Fixture x; x.c.controller.target_gray=100; x.track(100);
    auto r=x.next(80); CHECK(r.control.same_direction_count==1);
    const auto count=x.module.history().size();
    r=x.module.processFrame(imageFrame(x.time,80)); CHECK(!r.accepted && r.reason==Reason::DuplicateFrame);
    CHECK(r.control.same_direction_count==1 && !r.suggested_exposure_us);
    r=x.module.processFrame(imageFrame(x.time-1,80)); CHECK(!r.accepted && r.reason==Reason::OutOfOrderFrame);
    CHECK(x.module.history().size()==count && r.control.integral==0);
    r=x.next(80); CHECK(r.adjustment_suggested && r.control.same_direction_count==2);
}
TEST(feedback, actual_exposure_not_previous_advice_is_used) {
    Fixture x; x.track(); auto first=x.next(40,true,1000); auto second=x.next(40,true,1000);
    NEAR(*first.suggested_exposure_us,1250,0); NEAR(*second.suggested_exposure_us,1250,0);
    const auto applied=x.next(40,true,1250); NEAR(*applied.suggested_exposure_us,1562.5,0);
}
TEST(feedback, invalid_roi_holds_integral_and_breaks_confirmation) {
    Fixture x; x.c.controller.target_gray=100; x.track(100); x.next(80); auto r=x.next(80);
    NEAR(r.control.integral,.2,1e-12);
    auto f=imageFrame(x.time+1'000'000,80); f.roi.rectangles.clear(); r=x.send(f);
    CHECK(!r.adjustment_suggested && r.reason==Reason::InvalidMetering);
    NEAR(r.control.integral,.2,1e-12); CHECK(r.control.same_direction_count==0);
    CHECK(x.next(80).reason==Reason::ConfirmingError);
}
TEST(feedback, invalid_exposure_clock_change_and_reset) {
    Fixture x; x.track(); const auto size=x.module.history().size();
    CHECK(x.module.preCapture(x.time+1,x.c).accepted);
    auto f=imageFrame(x.time+1); f.actual_exposure_us=std::numeric_limits<double>::quiet_NaN();
    auto r=x.module.processFrame(f); CHECK(!r.accepted && r.reason==Reason::InvalidActualExposure);
    CHECK(x.module.history().size()==size);
    CHECK(!x.module.preCapture(x.time-1,x.c).accepted);
    x.module.reset(ResetReason::ClockChanged);
    auto p=x.module.preCapture(0,x.c); CHECK(p.accepted && p.initialization_required);
    CHECK(x.module.processFrame(imageFrame(0)).accepted);
}
TEST(feedback, exposure_outside_configured_range_is_reported_not_clipped_as_feedback) {
    Fixture x; x.track(); CHECK(x.module.preCapture(x.time+1,x.c).accepted);
    const auto r=x.module.processFrame(imageFrame(x.time+1,80,true,20000));
    CHECK(!r.accepted && r.reason==Reason::InvalidActualExposure && !r.suggested_exposure_us);
    NEAR(r.actual_exposure_us,20000,0);
    CHECK(x.module.history().size()==1);
}

TEST(config, reject_invalid_contract_without_accepting_frames) {
    Config empty; CHECK(!validate(empty).empty());
    Fixture x; CHECK(validate(x.c).empty());
    auto bad=x.c; bad.metering.trim_fraction_each_side=.5;
    CHECK(!x.module.preCapture(0,bad).accepted);
    CHECK(!x.module.processFrame(imageFrame(0)).accepted);
    bad=x.c; bad.prediction.points=4; CHECK(!validate(bad).empty());
    bad=x.c; bad.controller.target_gray=0; CHECK(!validate(bad).empty());
    bad=x.c; bad.max_exposure_us=500; CHECK(!validate(bad).empty());
    bad=x.c; bad.recovery.max_step_ratio=.5; CHECK(!validate(bad).empty());
    CHECK(x.module.preCapture(0,x.c).accepted);
}
TEST(config, independent_instances_do_not_share_state) {
    Fixture a,b; a.track(); a.next(40);
    CHECK(b.module.state()==State::CAPTURE && b.module.history().empty());
    CHECK(b.module.preCapture(0,b.c).initialization_required);
}

ContinuousFrameInput feedbackFrame(TimestampUs time, int globalGray = 80,
                                  FeedbackSource source = FeedbackSource::Global,
                                  std::optional<int> regionGray = {}, double actual = 1000) {
    ContinuousFrameInput input;
    input.timestamp_us = time; input.actual_exposure_us = actual; input.source = source;
    input.metering = measureImage(cv::Mat(10, 10, CV_8UC1, cv::Scalar(globalGray)), {}, false);
    if (regionGray) {
        Roi roi; roi.rectangles.emplace_back(0, 0, 10, 10);
        input.metering.target = measureImage(cv::Mat(10, 10, CV_8UC1, cv::Scalar(*regionGray)), roi, true).target;
    }
    return input;
}
ContinuousConfig feedbackConfig() {
    ContinuousConfig config;
    config.min_exposure_us = 100; config.max_exposure_us = 10000;
    config.region_controller.target_gray = config.global_controller.target_gray = 100;
    return config;
}
TEST(continuous, no_target_feedback_converges_without_a_recovery_budget) {
    ContinuousExposureControl control; const auto c = feedbackConfig();
    double actual = 1000; int adjustments = 0;
    ContinuousFrameResult result;
    for (int i = 0; i < 40; ++i) {
        const int gray = std::clamp(static_cast<int>(std::round(actual * .02)), 0, 255);
        result = control.update(feedbackFrame(i, gray, FeedbackSource::YoloRegions, {}, actual), c);
        CHECK(result.accepted && result.effective_source == FeedbackSource::Global);
        CHECK(result.metering.target.status == MeterStatus::NoTarget);
        CHECK(result.fallback_reason == FeedbackFallbackReason::RegionUnavailable);
        CHECK(std::abs(result.control.limited_delta_exposure_us) <= actual * .25 + 1e-9);
        if (result.adjustment_suggested) ++adjustments;
        actual = *result.suggested_exposure_us;
    }
    CHECK(adjustments > 3);
    CHECK(result.state == FeedbackState::Holding && !result.adjustment_suggested);
    CHECK(*result.control_gray >= 88 && *result.control_gray <= 112);
}
TEST(continuous, manual_and_yolo_regions_take_priority_then_fallback_explicitly) {
    ContinuousExposureControl control; const auto c = feedbackConfig();
    auto result = control.update(feedbackFrame(0, 0, FeedbackSource::ManualRoi, 100), c);
    CHECK(result.effective_source == FeedbackSource::ManualRoi && result.reason == Reason::Deadband);
    CHECK(result.fallback_reason == FeedbackFallbackReason::None && *result.control_gray == 100);
    result = control.update(feedbackFrame(1, 255, FeedbackSource::YoloRegions, 20), c);
    CHECK(result.effective_source == FeedbackSource::YoloRegions && result.adjustment_suggested);
    CHECK(*result.suggested_exposure_us == 1250 && result.reset_reason == FeedbackResetReason::SourceChanged);
    result = control.update(feedbackFrame(2, 100, FeedbackSource::YoloRegions), c);
    CHECK(result.effective_source == FeedbackSource::Global && result.reason == Reason::Deadband);
    CHECK(result.fallback_reason == FeedbackFallbackReason::RegionUnavailable);
    auto invalid = feedbackFrame(3, 20, FeedbackSource::ManualRoi);
    invalid.metering.target.status = MeterStatus::InvalidRoi;
    result = control.update(invalid, c);
    CHECK(result.accepted && result.fallback_reason == FeedbackFallbackReason::InvalidRegionMeasurement);
    CHECK(result.effective_source == FeedbackSource::Global && !result.reset_reason);
}
TEST(continuous, source_changes_clear_integral_and_direction_count) {
    ContinuousExposureControl control; const auto c = feedbackConfig();
    CHECK(control.update(feedbackFrame(0, 80, FeedbackSource::ManualRoi, 80), c).reason == Reason::ConfirmingError);
    auto result = control.update(feedbackFrame(1, 80, FeedbackSource::ManualRoi, 80), c);
    NEAR(result.control.integral, .2, 1e-12);
    result = control.update(feedbackFrame(2), c);
    CHECK(result.reset_reason == FeedbackResetReason::SourceChanged && result.reason == Reason::ConfirmingError);
    CHECK(result.control.integral == 0 && result.control.same_direction_count == 1);
    result = control.update(feedbackFrame(3), c);
    NEAR(result.control.integral, .2, 1e-12);
    result = control.update(feedbackFrame(4, 80, FeedbackSource::YoloRegions, 80), c);
    CHECK(result.reset_reason == FeedbackResetReason::SourceChanged && result.control.integral == 0);
}
TEST(continuous, global_reference_is_independent_of_region_reference) {
    ContinuousExposureControl control; auto c = feedbackConfig();
    c.region_controller.target_gray = 180; c.global_controller.target_gray = 100;
    auto result = control.update(feedbackFrame(0, 100, FeedbackSource::YoloRegions), c);
    CHECK(result.target_gray == 100 && result.reason == Reason::Deadband);
    result = control.update(feedbackFrame(1, 100, FeedbackSource::YoloRegions, 100), c);
    CHECK(result.target_gray == 180 && result.reason == Reason::ProportionalAdjustment);
}
TEST(continuous, black_saturation_step_limits_and_exposure_limits_are_traced) {
    ContinuousExposureControl control; const auto c = feedbackConfig();
    auto result = control.update(feedbackFrame(0, 0), c);
    CHECK(result.state == FeedbackState::Adjusting && result.control.step_limited);
    NEAR(result.control.raw_delta_exposure_us, 700, 1e-10);
    NEAR(result.control.limited_delta_exposure_us, 250, 0);
    CHECK(result.metering.global.near_black_fraction == 1);
    result = control.update(feedbackFrame(1, 255), c);
    CHECK(*result.suggested_exposure_us == 750 && result.metering.global.saturated_fraction == 1);
    CHECK(result.control.current_error_ratio == result.control.control_error_ratio);
    result = control.update(feedbackFrame(2, 0, FeedbackSource::Global, {}, 10000), c);
    CHECK(result.state == FeedbackState::Limited && result.reason == Reason::ExposureLimit);
    CHECK(!result.adjustment_suggested && result.control.exposure_limited);
    result = control.update(feedbackFrame(3, 255, FeedbackSource::Global, {}, 100), c);
    CHECK(result.state == FeedbackState::Limited && *result.suggested_exposure_us == 100);
}
TEST(continuous, new_config_and_idle_interval_reset_controller) {
    ContinuousExposureControl control; auto c = feedbackConfig();
    CHECK(control.update(feedbackFrame(0), c).reset_reason == FeedbackResetReason::Startup);
    NEAR(control.update(feedbackFrame(1), c).control.integral, .2, 1e-12);
    c.global_controller.kp = .3;
    auto result = control.update(feedbackFrame(2), c);
    CHECK(result.reset_reason == FeedbackResetReason::ConfigurationChanged && result.control.integral == 0);
    result = control.update(feedbackFrame(3), c); NEAR(result.control.integral, .2, 1e-12);
    result = control.update(feedbackFrame(c.idle_timeout_us + 4), c);
    CHECK(result.reset_reason == FeedbackResetReason::IdleTimeout && result.control.integral == 0);
    CHECK(result.reason == Reason::ConfirmingError);
}
TEST(continuous, duplicates_out_of_order_and_manual_reset_keep_timestamp_watermark) {
    ContinuousExposureControl control; const auto c = feedbackConfig();
    control.update(feedbackFrame(10), c);
    auto result = control.update(feedbackFrame(10), c);
    CHECK(!result.accepted && result.reason == Reason::DuplicateFrame && !result.suggested_exposure_us);
    CHECK(result.control.same_direction_count == 1);
    CHECK(control.update(feedbackFrame(9), c).reason == Reason::OutOfOrderFrame);
    result = control.update(feedbackFrame(11), c);
    CHECK(result.accepted && result.control.same_direction_count == 2);
    control.reset();
    CHECK(control.update(feedbackFrame(0), c).reason == Reason::OutOfOrderFrame);
    result = control.update(feedbackFrame(12), c);
    CHECK(result.reset_reason == FeedbackResetReason::Manual && result.control.integral == 0);
    control.reset(FeedbackResetReason::ClockChanged);
    result = control.update(feedbackFrame(0), c);
    CHECK(result.accepted && result.reset_reason == FeedbackResetReason::ClockChanged);
}
TEST(continuous, invalid_feedback_is_rejected_without_consuming_frame_or_state) {
    ContinuousExposureControl control; const auto c = feedbackConfig();
    control.update(feedbackFrame(0), c);
    auto bad = feedbackFrame(1); bad.metering.global.gray = std::numeric_limits<double>::quiet_NaN();
    auto result = control.update(bad, c);
    CHECK(!result.accepted && result.reason == Reason::InvalidMetering && !result.suggested_exposure_us);
    CHECK(!result.effective_source && !result.errors.empty() && result.control.same_direction_count == 1);
    bad = feedbackFrame(1); bad.metering.global.saturated_fraction = 1.5;
    CHECK(!control.update(bad, c).accepted);
    bad = feedbackFrame(1); bad.metering.global.pixels = 0;
    CHECK(!control.update(bad, c).accepted);
    bad = feedbackFrame(1); bad.metering.global.retained_pixels = 101;
    CHECK(!control.update(bad, c).accepted);
    result = control.update(feedbackFrame(1), c);
    CHECK(result.accepted && result.control.same_direction_count == 2);
    NEAR(result.control.integral, .2, 1e-12);
}
TEST(continuous, invalid_exposure_config_and_time_do_not_initialize) {
    ContinuousExposureControl control; const auto c = feedbackConfig();
    CHECK(control.update(feedbackFrame(-1), c).reason == Reason::InvalidTimestamp);
    for (double actual : {0.0, 99.0, 10001.0, std::numeric_limits<double>::quiet_NaN()}) {
        const auto result = control.update(feedbackFrame(0, 80, FeedbackSource::Global, {}, actual), c);
        CHECK(!result.accepted && result.reason == Reason::InvalidActualExposure && !result.suggested_exposure_us);
    }
    auto badConfig = c; badConfig.global_controller.target_gray = 0;
    CHECK(control.update(feedbackFrame(0), badConfig).reason == Reason::InvalidConfiguration);
    badConfig = c; badConfig.region_controller.max_step_ratio = 1;
    CHECK(!validate(badConfig).empty());
    auto badInput = feedbackFrame(0); badInput.source = static_cast<FeedbackSource>(100);
    CHECK(control.update(badInput, c).reason == Reason::InvalidConfiguration);
    const auto result = control.update(feedbackFrame(0), c);
    CHECK(result.accepted && result.reset_reason == FeedbackResetReason::Startup);
}
TEST(continuous, actual_exposure_not_unapplied_previous_advice_is_used) {
    ContinuousExposureControl control; const auto c = feedbackConfig();
    const auto first = control.update(feedbackFrame(0, 20), c);
    const auto retry = control.update(feedbackFrame(1, 20), c);
    NEAR(*first.suggested_exposure_us, 1250, 0);
    NEAR(*retry.suggested_exposure_us, 1250, 0);
    const auto applied = control.update(feedbackFrame(2, 20, FeedbackSource::Global, {}, 1250), c);
    NEAR(*applied.suggested_exposure_us, 1562.5, 0);
}
TEST(continuous, anti_windup_and_independent_instances_are_preserved) {
    ContinuousExposureControl a, b; auto c = feedbackConfig();
    c.global_controller.kp = 2; c.global_controller.ki = 1;
    a.update(feedbackFrame(0), c);
    const auto result = a.update(feedbackFrame(1), c);
    CHECK(result.control.integral_blocked_by_limit && result.control.step_limited);
    CHECK(result.control.integral == 0 && result.control.same_direction_count == 2);
    const auto independent = b.update(feedbackFrame(0), c);
    CHECK(independent.reset_reason == FeedbackResetReason::Startup);
    CHECK(independent.reason == Reason::ConfirmingError && independent.control.same_direction_count == 1);
}
TEST(continuous, sparse_frames_preserve_confirmation_without_accumulating_stale_integral) {
    ContinuousExposureControl control; auto c = feedbackConfig();
    c.preserve_confirmation_on_idle = true;
    const TimestampUs interval = c.idle_timeout_us + 1;
    auto result = control.update(feedbackFrame(0), c);
    CHECK(result.reason == Reason::ConfirmingError && result.control.same_direction_count == 1);
    for (int frame = 1; frame <= 4; ++frame) {
        result = control.update(feedbackFrame(frame * interval), c);
        CHECK(result.accepted && result.reset_reason == FeedbackResetReason::IdleTimeout);
        CHECK(result.reason == Reason::PiAdjustment && result.control.same_direction_count == 2);
        CHECK(result.control.integral == 0 && result.control.integral_suppressed);
        NEAR(*result.suggested_exposure_us, 1080, 1e-9);
    }
    // A subsequent close frame may integrate normally; the sparse frames do not.
    result = control.update(feedbackFrame(4 * interval + 1), c);
    CHECK(!result.reset_reason && !result.control.integral_suppressed);
    NEAR(result.control.integral, .2, 1e-12);
    // An idle gap after accumulated integral clears that integral before computing.
    result = control.update(feedbackFrame(5 * interval + 1), c);
    CHECK(result.control.integral == 0 && result.control.integral_suppressed);
    NEAR(*result.suggested_exposure_us, 1080, 1e-9);
}
TEST(continuous, sparse_idle_preserves_hysteresis_and_reconfirms_after_direction_change) {
    ContinuousExposureControl control; auto c = feedbackConfig();
    c.preserve_confirmation_on_idle = true;
    const TimestampUs interval = c.idle_timeout_us + 1;
    control.update(feedbackFrame(0), c);
    // 11 percent error is outside the deadband but inside the re-entry hysteresis.
    auto result = control.update(feedbackFrame(interval, 89), c);
    CHECK(result.adjustment_suggested && result.control.same_direction_count == 2);
    result = control.update(feedbackFrame(2 * interval, 120), c);
    CHECK(result.reason == Reason::ConfirmingError && result.control.same_direction_count == 1);
    result = control.update(feedbackFrame(3 * interval, 120), c);
    CHECK(result.adjustment_suggested && *result.suggested_exposure_us < 1000);
    result = control.update(feedbackFrame(4 * interval, 100), c);
    CHECK(result.reason == Reason::Deadband && result.control.same_direction_count == 0);
    result = control.update(feedbackFrame(5 * interval, 89), c);
    CHECK(result.reason == Reason::Hysteresis && result.control.same_direction_count == 0);
}
TEST(continuous, idle_option_preserves_default_and_never_weakens_explicit_or_context_resets) {
    ContinuousExposureControl control; auto c = feedbackConfig();
    const TimestampUs interval = c.idle_timeout_us + 1;
    control.update(feedbackFrame(0), c);
    for (int frame = 1; frame <= 3; ++frame) {
        auto result = control.update(feedbackFrame(frame * interval), c);
        CHECK(result.reason == Reason::ConfirmingError && result.control.same_direction_count == 1);
        CHECK(!result.control.integral_suppressed);
    }
    const auto oldConfig = c;
    c.preserve_confirmation_on_idle = true;
    CHECK(c != oldConfig);
    auto result = control.update(feedbackFrame(4 * interval), c);
    CHECK(result.reset_reason == FeedbackResetReason::ConfigurationChanged);
    CHECK(result.reason == Reason::ConfirmingError && result.control.same_direction_count == 1);
    result = control.update(feedbackFrame(5 * interval, 80, FeedbackSource::ManualRoi, 80), c);
    CHECK(result.reset_reason == FeedbackResetReason::SourceChanged);
    CHECK(result.reason == Reason::ConfirmingError && result.control.same_direction_count == 1);
    for (const auto reason : {FeedbackResetReason::Manual, FeedbackResetReason::IdleTimeout,
                             FeedbackResetReason::ClockChanged}) {
        control.reset(reason);
        result = control.update(feedbackFrame(6 * interval, 80, FeedbackSource::ManualRoi, 80), c);
        CHECK(result.reset_reason == reason && result.reason == Reason::ConfirmingError);
        CHECK(result.control.same_direction_count == 1 && !result.control.integral_suppressed);
        result = control.update(feedbackFrame(7 * interval, 80, FeedbackSource::ManualRoi, 80), c);
        CHECK(result.adjustment_suggested);
        // Keep the next explicit reset's accepted timestamp strictly newer.
        control.reset(FeedbackResetReason::ClockChanged);
    }
}
TEST(continuous, external_override_clears_integral_without_restarting_confirmation) {
    ContinuousExposureControl control; const auto c = feedbackConfig();
    control.update(feedbackFrame(0), c);
    auto result = control.update(feedbackFrame(1), c);
    NEAR(result.control.integral, .2, 1e-12);
    for (TimestampUs time = 2; time <= 4; ++time) {
        auto input = feedbackFrame(time); input.suppress_integral = true;
        result = control.update(input, c);
        CHECK(result.accepted && !result.reset_reason && result.adjustment_suggested);
        CHECK(result.control.integral_suppressed && result.control.integral == 0);
        CHECK(result.control.same_direction_count == 2);
        NEAR(*result.suggested_exposure_us, 1080, 1e-9);
    }
    result = control.update(feedbackFrame(5), c);
    CHECK(!result.control.integral_suppressed);
    NEAR(result.control.integral, .2, 1e-12);
    auto deadband = feedbackFrame(6, 100); deadband.suppress_integral = true;
    result = control.update(deadband, c);
    CHECK(result.reason == Reason::Deadband && result.control.integral == 0 && result.control.integral_suppressed);
    auto confirming = feedbackFrame(7); confirming.suppress_integral = true;
    result = control.update(confirming, c);
    CHECK(result.reason == Reason::ConfirmingError && result.control.same_direction_count == 1);
    result = control.update(feedbackFrame(8), c);
    CHECK(result.adjustment_suggested && result.control.same_direction_count == 2);
}
TEST(continuous, rejected_override_inputs_do_not_clear_integral_or_consume_time_and_configuration) {
    ContinuousExposureControl control; const auto c = feedbackConfig();
    control.update(feedbackFrame(0), c);
    NEAR(control.update(feedbackFrame(1), c).control.integral, .2, 1e-12);
    const auto rejected = [&](ContinuousFrameInput bad, const ContinuousConfig& config) {
        bad.suppress_integral = true;
        const auto result = control.update(bad, config);
        CHECK(!result.accepted && !result.control.integral_suppressed);
        CHECK(result.control.same_direction_count == 2);
        NEAR(result.control.integral, .2, 1e-12);
    };
    rejected(feedbackFrame(1), c);
    rejected(feedbackFrame(0), c);
    rejected(feedbackFrame(-1), c);
    rejected(feedbackFrame(2, 80, FeedbackSource::Global, {}, 0), c);
    auto bad = feedbackFrame(2); bad.metering.global.gray = std::numeric_limits<double>::quiet_NaN();
    auto changed = c; changed.preserve_confirmation_on_idle = true;
    rejected(bad, changed);
    bad = feedbackFrame(2); bad.source = static_cast<FeedbackSource>(999);
    rejected(bad, c);
    auto invalid = changed; invalid.global_controller.target_gray = 0;
    rejected(feedbackFrame(2), invalid);
    const auto result = control.update(feedbackFrame(2), c);
    CHECK(result.accepted && !result.reset_reason && result.control.same_direction_count == 2);
    NEAR(result.control.integral, .4, 1e-12);
}
TEST(continuous, reached_target_and_error_reversal_clear_obsolete_integral) {
    for (const bool timeAware : {false, true}) {
        ContinuousExposureControl control; auto c = feedbackConfig(); c.time_aware = timeAware;
        c.global_controller.target_gray = 118;
        double actual = 5000;
        TimestampUs time = 0;
        for (int i = 0; i < 7; ++i, time += 5'000'000) {
            const auto r = control.update(feedbackFrame(time, 100, FeedbackSource::Global, {}, actual), c);
            actual = *r.suggested_exposure_us;
        }
        for (int i = 0; i < 2; ++i, time += 5'000'000) {
            const auto r = control.update(feedbackFrame(time, 118, FeedbackSource::Global, {}, actual), c);
            CHECK(r.control.integral == 0 && !r.adjustment_suggested);
        }
        for (int i = 0; i < 3; ++i, time += 5'000'000) {
            const auto r = control.update(feedbackFrame(time, 134, FeedbackSource::Global, {}, actual), c);
            CHECK(*r.suggested_exposure_us <= actual && r.control.integral <= 0);
            actual = *r.suggested_exposure_us;
        }
        control.reset(FeedbackResetReason::ClockChanged);
        control.update(feedbackFrame(0, 100), c);
        const auto dark = control.update(feedbackFrame(5'000'000, 100), c);
        CHECK(dark.control.integral > 0);
        const auto reversed = control.update(feedbackFrame(10'000'000, 134), c);
        CHECK(reversed.control.integral == 0 && *reversed.suggested_exposure_us <= 1000);
    }
}
TEST(controller, original_entrypoint_clears_integral_on_return_and_reversal) {
    Fixture x; x.c.controller.target_gray = 118; x.track(118);
    for (int i = 0; i < 7; ++i) x.next(100);
    auto r = x.next(118); CHECK(r.control.integral == 0);
    x.next(118);
    for (int i = 0; i < 3; ++i) {
        r = x.next(134); CHECK(*r.suggested_exposure_us <= 1000 && r.control.integral <= 0);
    }
    x.next(100); x.next(100);
    r = x.next(134); CHECK(r.control.integral == 0 && !r.adjustment_suggested);
}
TEST(continuous, elapsed_time_limits_rate_and_integral_at_multiple_intervals) {
    for (const TimestampUs interval : {TimestampUs{100'000}, TimestampUs{1'000'000},
                                     TimestampUs{5'000'000}, TimestampUs{60'000'000}}) {
        ContinuousExposureControl control; auto c = feedbackConfig(); c.time_aware = true;
        const auto first = control.update(feedbackFrame(0, 20), c);
        CHECK(first.control.elapsed_us == c.nominal_interval_us);
        const auto r = control.update(feedbackFrame(interval, 20), c);
        const double expectedStep = std::min(.25, .05 * interval / 1'000'000.0);
        NEAR(*r.suggested_exposure_us, 1000 * (1 + expectedStep), 1e-8);
        NEAR(r.control.effective_max_step_ratio, expectedStep, 1e-12);
        CHECK(r.control.time_rate_limited == (interval < 5'000'000));
        CHECK(r.control.elapsed_us == interval && r.control.filter_alpha == 1);
        control.reset(FeedbackResetReason::ClockChanged);
        c.confirmation_us = 0;
        CHECK(control.update(feedbackFrame(0), c).reason == Reason::ConfirmingError);
        const auto small = control.update(feedbackFrame(interval), c);
        CHECK(small.control.same_direction_count == 2);
        NEAR(small.control.integral_time_scale, std::min(1.0, interval / 5'000'000.0), 1e-12);
        if (interval >= 5'000'000) NEAR(small.control.integral, .2, 1e-12);
    }
}
TEST(continuous, time_confirmation_requires_duration_and_two_samples) {
    ContinuousExposureControl control; auto c = feedbackConfig(); c.time_aware = true;
    c.global_controller.same_direction_frames = 1;
    CHECK(control.update(feedbackFrame(0), c).reason == Reason::ConfirmingError);
    for (int i = 1; i < 10; ++i) {
        const auto r = control.update(feedbackFrame(i * 100'000), c);
        CHECK(r.reason == Reason::ConfirmingError && !r.control.confirmation_time_satisfied);
        CHECK(r.control.integral == 0);
    }
    const auto r = control.update(feedbackFrame(1'000'000), c);
    CHECK(r.adjustment_suggested && r.control.confirmation_time_satisfied);
    CHECK(r.control.same_direction_duration_us == 1'000'000);
    NEAR(r.control.integral_time_scale, .02, 1e-12);
}
TEST(continuous, smoothing_normalizes_exposure_and_never_reverses_raw_error) {
    ContinuousExposureControl control; auto c = feedbackConfig(); c.time_aware = true;
    control.update(feedbackFrame(0, 80), c);
    // Same scene response at changed exposure must not be mistaken for light drift.
    auto r = control.update(feedbackFrame(100'000, 88, FeedbackSource::Global, {}, 1100), c);
    NEAR(*r.control_gray, 88, 1e-10);
    NEAR(*r.raw_control_gray, 88, 0);
    CHECK(r.control.filter_alpha > 0 && r.control.filter_alpha < 1);
    r = control.update(feedbackFrame(200'000, 120, FeedbackSource::Global, {}, 1100), c);
    CHECK(*r.control_gray == 120 && r.control.filter_alpha == 1);
    CHECK(*r.suggested_exposure_us <= 1100 && r.control.integral <= 0);
    r = control.update(feedbackFrame(300'000, 100, FeedbackSource::Global, {}, 1100), c);
    CHECK(r.reason == Reason::Deadband && !r.adjustment_suggested && r.control.integral == 0);
    auto overrideFrame = feedbackFrame(400'000, 90); overrideFrame.suppress_integral = true;
    r = control.update(overrideFrame, c);
    CHECK(*r.control_gray == 90 && r.control.filter_alpha == 1 && r.control.integral == 0);
}
TEST(continuous, timed_resets_and_long_gaps_clear_filter_without_stale_integral) {
    ContinuousExposureControl control; auto c = feedbackConfig();
    c.time_aware = true; c.preserve_confirmation_on_idle = true;
    control.update(feedbackFrame(0), c);
    auto r = control.update(feedbackFrame(3'600'000'000), c);
    CHECK(r.adjustment_suggested && r.control.integral == 0 && r.control.integral_time_scale == 0);
    CHECK(r.control.filter_alpha == 1 && r.control.same_direction_duration_us == 3'600'000'000);
    for (const auto reason : {FeedbackResetReason::Manual, FeedbackResetReason::ClockChanged}) {
        control.reset(reason);
        r = control.update(feedbackFrame(3'601'000'000, 85), c);
        CHECK(r.reset_reason == reason && r.control.filter_alpha == 1 && *r.control_gray == 85);
        CHECK(r.reason == Reason::ConfirmingError && r.control.same_direction_duration_us == 0);
    }
    r = control.update(feedbackFrame(3'602'000'000, 85, FeedbackSource::ManualRoi, 90), c);
    CHECK(r.reset_reason == FeedbackResetReason::SourceChanged && r.control.filter_alpha == 1);
    ++c.confirmation_us;
    r = control.update(feedbackFrame(3'603'000'000, 85, FeedbackSource::ManualRoi, 90), c);
    CHECK(r.reset_reason == FeedbackResetReason::ConfigurationChanged && r.control.filter_alpha == 1);
}
TEST(continuous, rejected_frames_do_not_consume_temporal_filter_or_timestamps) {
    ContinuousExposureControl a, b; auto c = feedbackConfig(); c.time_aware = true;
    a.update(feedbackFrame(0), c); b.update(feedbackFrame(0), c);
    auto bad = feedbackFrame(500'000, 255); bad.actual_exposure_us = 0;
    CHECK(!a.update(bad, c).accepted);
    bad = feedbackFrame(500'000, 255); bad.metering.global.gray = -1;
    CHECK(!a.update(bad, c).accepted);
    for (int field = 0; field < 4; ++field) {
        auto invalid = c;
        if (field == 0) invalid.nominal_interval_us = 0;
        if (field == 1) invalid.smoothing_tau_us = -1;
        if (field == 2) invalid.confirmation_us = -1;
        if (field == 3) invalid.max_step_ratio_per_second = 0;
        CHECK(!a.update(feedbackFrame(500'000, 255), invalid).accepted);
    }
    const auto x = a.update(feedbackFrame(1'000'000, 85), c);
    const auto y = b.update(feedbackFrame(1'000'000, 85), c);
    CHECK(x.reason == y.reason && x.control_gray == y.control_gray && x.suggested_exposure_us == y.suggested_exposure_us);
    CHECK(x.control.elapsed_us == y.control.elapsed_us && x.control.integral == y.control.integral);
    CHECK(x.control.same_direction_duration_us == y.control.same_direction_duration_us);
}
TEST(continuous, tiny_finite_exposure_cannot_poison_temporal_filter) {
    ContinuousExposureControl control; auto c = feedbackConfig();
    c.time_aware = true; c.min_exposure_us = 1e-320;
    for (int i = 0; i < 3; ++i) {
        const auto r = control.update(feedbackFrame(i * 1'000'000, 80, FeedbackSource::Global, {}, 1e-319), c);
        CHECK(r.accepted && r.control_gray == 80 && std::isfinite(*r.suggested_exposure_us));
        CHECK(std::isfinite(r.control.integral));
    }
}
ContinuousConfig predictionConfig() {
    auto c = feedbackConfig(); c.time_aware = true; c.max_exposure_us = 30000;
    c.region_controller.target_gray = c.global_controller.target_gray = 118;
    return c;
}
ContinuousFrameInput predictionFrame(TimestampUs time, int gray, double predicted) {
    auto input = feedbackFrame(time, gray, FeedbackSource::ManualRoi, gray, 10000);
    input.predicted_gray = predicted;
    return input;
}
TEST(continuous, prediction_uses_shared_deadband_hysteresis_and_confirmation) {
    ContinuousExposureControl control; const auto c = predictionConfig();
    auto r = control.update(predictionFrame(0, 110, 110), c);
    CHECK(r.accepted && !r.prediction_used && r.reset_reason == FeedbackResetReason::Startup);
    r = control.update(predictionFrame(5'000'000, 110, 110), c);
    CHECK(r.prediction_used && r.reason == Reason::Deadband && *r.suggested_exposure_us == 10000);
    r = control.update(predictionFrame(10'000'000, 105, 105), c);
    CHECK(r.prediction_used && r.reason == Reason::Hysteresis && *r.suggested_exposure_us == 10000);
    r = control.update(predictionFrame(15'000'000, 110, 102), c);
    CHECK(r.prediction_used && r.reason == Reason::ConfirmingError && !r.adjustment_suggested);
    CHECK(r.control.same_direction_count == 1 && r.control.integral == 0);
    r = control.update(predictionFrame(20'000'000, 110, 101), c);
    CHECK(r.prediction_used && r.reason == Reason::PiAdjustment && r.adjustment_suggested);
    CHECK(r.control.same_direction_count == 2 && r.control.confirmation_time_satisfied);
    CHECK(*r.suggested_exposure_us > 10000 && *r.suggested_exposure_us <= 11000);
    CHECK(r.feedback_reason == Reason::Deadband && *r.feedback_suggested_exposure_us == 10000);
    CHECK(r.metering.target.gray == 110 && r.raw_control_gray == 110 && r.feedback_control_gray == 110);
    CHECK(r.control.filtered_gray == 110 && r.control_gray == 101);
    NEAR(*r.control.current_error_ratio, 8.0 / 118, 1e-12);
    NEAR(*r.control.control_error_ratio, 17.0 / 118, 1e-12);
}
TEST(continuous, prediction_keeps_time_confirmation_and_both_step_limits) {
    ContinuousExposureControl control; auto c = predictionConfig();
    control.update(predictionFrame(0, 110, 110), c);
    auto r = control.update(predictionFrame(100'000, 110, 80), c);
    CHECK(r.reason == Reason::ConfirmingError);
    r = control.update(predictionFrame(200'000, 110, 80), c);
    CHECK(r.reason == Reason::ConfirmingError && !r.control.confirmation_time_satisfied);
    r = control.update(predictionFrame(1'100'000, 110, 80), c);
    CHECK(r.adjustment_suggested && r.control.confirmation_time_satisfied && r.control.time_rate_limited);
    NEAR(*r.suggested_exposure_us, 10450, 1e-8);
    r = control.update(predictionFrame(6'100'000, 110, 60), c);
    CHECK(r.adjustment_suggested && r.control.step_limited && !r.control.time_rate_limited);
    NEAR(*r.suggested_exposure_us, 11000, 1e-8);
    control.reset();
    c.time_aware = false;
    control.update(predictionFrame(7'000'000, 110, 110), c);
    r = control.update(predictionFrame(8'000'000, 110, 80), c);
    CHECK(r.reason == Reason::ConfirmingError);
    r = control.update(predictionFrame(9'000'000, 110, 80), c);
    CHECK(r.adjustment_suggested && *r.suggested_exposure_us <= 11000);
}
TEST(continuous, prediction_cannot_override_active_feedback_or_protection_resets) {
    const auto c = predictionConfig();
    for (int scenario = 0; scenario < 5; ++scenario) {
        ContinuousExposureControl control;
        control.update(predictionFrame(0, 110, 110), c);
        auto input = predictionFrame(5'000'000, 110, 60);
        if (scenario == 0) input = predictionFrame(5'000'000, 60, 200);
        if (scenario == 1) input.source = FeedbackSource::Global;
        if (scenario == 2) input.suppress_integral = true;
        if (scenario == 3) control.reset(FeedbackResetReason::ClockChanged);
        if (scenario == 4) input.timestamp_us = c.idle_timeout_us + 1;
        const auto r = control.update(input, c);
        CHECK(r.accepted && !r.prediction_used && r.feedback_reason == r.reason);
        CHECK(r.feedback_suggested_exposure_us == r.suggested_exposure_us);
        if (scenario == 0) CHECK(r.adjustment_suggested && *r.suggested_exposure_us > 10000);
        else CHECK(!r.adjustment_suggested);
    }
}
TEST(continuous, rejected_prediction_does_not_mutate_feedback_state) {
    const auto c = predictionConfig(); ContinuousExposureControl a, b;
    a.update(predictionFrame(0, 110, 110), c); b.update(predictionFrame(0, 110, 110), c);
    a.update(predictionFrame(5'000'000, 110, 102), c); b.update(predictionFrame(5'000'000, 110, 102), c);
    auto bad = predictionFrame(6'000'000, 110, std::numeric_limits<double>::quiet_NaN());
    CHECK(!a.update(bad, c).accepted);
    bad.predicted_gray = 101; bad.prediction_max_step_ratio = 0;
    CHECK(!a.update(bad, c).accepted);
    const auto x = a.update(predictionFrame(10'000'000, 110, 101), c);
    const auto y = b.update(predictionFrame(10'000'000, 110, 101), c);
    CHECK(x.adjustment_suggested && x.reason == y.reason && x.suggested_exposure_us == y.suggested_exposure_us);
    CHECK(x.control.same_direction_count == y.control.same_direction_count && x.control.integral == y.control.integral);
}
} // namespace

int main(int argc,char** argv) {
    const std::string selected=argc>1?argv[1]:"";
    int total=0, failures=0;
    for(const auto& test:cases()) if(selected.empty()||test.group==selected) {
        ++total;
        try { test.run(); std::cout<<"PASS "<<test.group<<"/"<<test.name<<'\n'; }
        catch(const std::exception& error) { ++failures; std::cerr<<"FAIL "<<test.group<<"/"<<test.name<<": "<<error.what()<<'\n'; }
    }
    std::cout<<"RESULT "<<selected<<": "<<total-failures<<"/"<<total<<" passed\n";
    return failures||total==0?1:0;
}