// SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
// SPDX-License-Identifier: GPL-3.0-only

#include <catch2/catch_all.hpp>
#include <iostream>

#include "../image_analysis/rotation_indexer/RotationIndexer.h"
#include "../image_analysis/bragg_prediction/BraggPrediction.h"

TEST_CASE("RotationIndexer") {
    DiffractionExperiment exp_i;
    exp_i.IncidentEnergy_keV(WVL_1A_IN_KEV)
         .BeamX_pxl(1000)
         .BeamY_pxl(1000)
         .PoniRot1_rad(0.01)
         .PoniRot2_rad(0.02)
         .DetectorDistance_mm(200)
    .ImagesPerTrigger(50);

    IndexingSettings settings;
#ifdef JFJOCH_USE_CUDA
    settings.Algorithm(IndexingAlgorithmEnum::FFT);
#elif JFJOCH_USE_FFTW
    settings.Algorithm(IndexingAlgorithmEnum::FFTW);
#else
    return;
#endif

    settings.RotationIndexing(true).RotationIndexingAngularStride_deg(1.0).RotationIndexingMinAngularRange_deg(30.0);
    exp_i.ImportIndexingSettings(settings);

    // Base lattice (non-pathological)
    CrystalLattice latt_base(40, 50, 80, 90, 90, 90);
    latt_base = latt_base.Multiply(RotMatrix(2.0, Coord(sqrt(3)/3,sqrt(3)/3,sqrt(3)/3)));

    // Rotation axis: around X with 1 deg per image
    GoniometerAxis axis("omega", 0.0f, 1.0f, Coord(1,0,0), std::nullopt);
    exp_i.Goniometer(axis);

    BraggPredictionSettings prediction_settings{
        .high_res_A = 1.3,
        .ewald_dist_cutoff = 0.002
    };

    IndexerThreadPool indexer_thread_pool(exp_i.GetIndexingSettings());
    RotationIndexer indexer(exp_i, indexer_thread_pool);

    BraggPrediction prediction;

    int cnt = 0;

    // Predict reflections for images at 0-30 deg.
    for (int img = 0; img < 50; ++img) {
        std::vector<SpotToSave> spots;
        // For a rotated image, per-image lattice is obtained as Multiply(rot.transpose())
        const float angle_deg = axis.GetAngle_deg(img) + axis.GetWedge_deg() / 2.0f;
        const RotMatrix rot = axis.GetTransformationAngle(angle_deg);
        const CrystalLattice latt_img = latt_base.Multiply(rot.transpose());

        const auto n = prediction.Calc(exp_i, latt_img, prediction_settings);
        for (int i = 0; i < n; ++i) {
            const auto& r = prediction.GetReflections().at(i);
            SpotToSave s{};
            s.x = r.predicted_x;
            s.y = r.predicted_y;
            s.image = img;       // provide image index for rotation-aware refinement
            s.intensity = 1.0f;  // minimal positive value
            s.phi = angle_deg;
            s.ice_ring = false;
            s.indexed = true;
            spots.push_back(s);
        }

        indexer.ProcessImage(img, spots);
        if (img == 30)
            indexer.RunIndexing();

        auto result = indexer.GetLattice();
        if (result.has_value())
            cnt++;
    }

    CHECK(cnt == 20);
    // An indexer that ran records no error; only one that threw does. A caller reporting "no lattice"
    // to the user tells the two apart on this.
    CHECK_FALSE(indexer.GetIndexerError().has_value());

    auto ret = indexer.GetLattice();
    REQUIRE(ret.has_value());
    auto uc = ret->lattice.GetUnitCell();
    auto uc_ref = latt_base.GetUnitCell();
    REQUIRE(std::fabs(uc.a - uc_ref.a) < 0.1);
    REQUIRE(std::fabs(uc.b - uc_ref.b) < 0.1);
    REQUIRE(std::fabs(uc.c - uc_ref.c) < 0.1);
    REQUIRE(std::fabs(uc.alpha - uc_ref.alpha) < 0.1);
    REQUIRE(std::fabs(uc.beta - uc_ref.beta) < 0.1);
    REQUIRE(std::fabs(uc.gamma - uc_ref.gamma) < 0.1);
    CHECK(ret->search_result.centering == 'P');
    CHECK(ret->search_result.system == gemmi::CrystalSystem::Orthorhombic);
}

// RefineConstrained is what a caller reaches for when it has ADOPTED a symmetry the indexing never
// refined under - the intensities confirm a two-fold the spot positions never offered - and so holds
// a cell whose metric is still the free fit's. Give it such a cell: the lattice this crystal indexes
// on, sheared so that alpha is a degree off, which is what that situation looks like. The constraint
// has to take it back to a cell the group can describe, and the spots have to be happier for it.
TEST_CASE("RotationIndexer::RefineConstrained puts a free metric back on its class") {
    DiffractionExperiment exp_i;
    exp_i.IncidentEnergy_keV(WVL_1A_IN_KEV)
         .BeamX_pxl(1000)
         .BeamY_pxl(1000)
         .DetectorDistance_mm(200)
         .ImagesPerTrigger(50);

    IndexingSettings settings;
#ifdef JFJOCH_USE_CUDA
    settings.Algorithm(IndexingAlgorithmEnum::FFT);
#elif JFJOCH_USE_FFTW
    settings.Algorithm(IndexingAlgorithmEnum::FFTW);
#else
    return;
#endif
    settings.RotationIndexing(true).RotationIndexingAngularStride_deg(1.0).RotationIndexingMinAngularRange_deg(30.0);
    exp_i.ImportIndexingSettings(settings);

    const CrystalLattice latt_base =
        CrystalLattice(40, 50, 80, 90, 105, 90).Multiply(RotMatrix(2.0, Coord(sqrt(3)/3, sqrt(3)/3, sqrt(3)/3)));

    GoniometerAxis axis("omega", 0.0f, 1.0f, Coord(1, 0, 0), std::nullopt);
    exp_i.Goniometer(axis);

    BraggPredictionSettings prediction_settings{ .high_res_A = 1.3, .ewald_dist_cutoff = 0.002 };
    IndexerThreadPool indexer_thread_pool(exp_i.GetIndexingSettings());
    RotationIndexer indexer(exp_i, indexer_thread_pool);
    BraggPrediction prediction;

    for (int img = 0; img < 50; ++img) {
        std::vector<SpotToSave> spots;
        const float angle_deg = axis.GetAngle_deg(img) + axis.GetWedge_deg() / 2.0f;
        const CrystalLattice latt_img = latt_base.Multiply(axis.GetTransformationAngle(angle_deg).transpose());
        const auto n = prediction.Calc(exp_i, latt_img, prediction_settings);
        for (int i = 0; i < n; ++i) {
            const auto &r = prediction.GetReflections().at(i);
            SpotToSave s{};
            s.x = r.predicted_x;
            s.y = r.predicted_y;
            s.image = img;
            s.intensity = 1.0f;
            s.phi = angle_deg;
            s.ice_ring = false;
            s.indexed = true;
            spots.push_back(s);
        }
        indexer.ProcessImage(img, spots);
        if (img == 30)
            indexer.RunIndexing();
    }

    REQUIRE(indexer.GetLattice().has_value());

    // Shear c along b: the orientation and two of the axes are untouched, and alpha - which the class
    // fixes at 90 - moves by about a degree. A free refinement that has walked into a class leaves
    // exactly this, a cell the group cannot describe standing in the group's own setting.
    const CrystalLattice sheared(latt_base.Vec0(), latt_base.Vec1(),
                                 latt_base.Vec2() + latt_base.Vec1() * 0.02f);
    CHECK(std::fabs(sheared.GetUnitCell().alpha - 90.0) > 0.5);

    const auto refit = indexer.RefineConstrained(sheared, gemmi::CrystalSystem::Monoclinic);
    REQUIRE(refit.has_value());
    const auto uc = refit->lattice.GetUnitCell();
    CHECK(uc.alpha == Catch::Approx(90.0).margin(1e-3));
    CHECK(uc.gamma == Catch::Approx(90.0).margin(1e-3));
    // ...and it is the cell the crystal has, not merely a cell obeying the constraint.
    CHECK(uc.a == Catch::Approx(40.0).margin(0.2));
    CHECK(uc.b == Catch::Approx(50.0).margin(0.2));
    CHECK(uc.c == Catch::Approx(80.0).margin(0.2));
    CHECK(uc.beta == Catch::Approx(105.0).margin(0.2));
    // The spots decide whether a caller keeps it, so the fractions have to be the real comparison:
    // the sheared cell indexes worse than the one the constraint brings back.
    CHECK(refit->indexed_fraction > refit->indexed_fraction_before);
    CHECK(refit->indexed_fraction > 0.5f);
}