#include <gtest/gtest.h>

#include <array>
#include <cmath>
#include <cstddef>
#include <filesystem>
#include <limits>
#include <memory>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>

#include "fesa/analysis/analysis_model.h"
#include "fesa/analysis/analysis_state.h"
#include "fesa/assembly/parallel_for.h"
#include "fesa/assembly/sparse_assembler.h"
#include "fesa/elements/element.h"
#include "fesa/fem/dof_manager.h"
#include "fesa/math/vector3.h"
#include "fesa/model/domain.h"
#include "results/analysis_state_commit.h"
#include "results/beam_result_recovery.h"
#include "results/global_equilibrium_recovery.h"
#include "results/recovery_candidate.h"
#include "results/shell_result_recovery.h"

namespace {

struct ShellFixture {
  std::unique_ptr<fesa::Domain> domain;
  std::unique_ptr<fesa::AnalysisModel> model;
  std::unique_ptr<fesa::DofManager> dofs;
  std::unique_ptr<fesa::SparseMatrix> stiffness;
};

fesa::SourceEntityId MakeSourceId(const std::string& text) {
  return {"Part-1", 10, text};
}

fesa::BeamElementResultRows MakeBeamRows(const fesa::EntityIndex element,
                                         const double value) {
  fesa::BeamElementResultRows rows{};
  rows.endpoint_rows = {{element,
                         0,
                         MakeSourceId("1"),
                         {-value, 0.0, 0.0, 0.0, 0.0, 0.0},
                         {value, 2.0 * value, 3.0 * value, 4.0 * value}},
                        {element,
                         1,
                         MakeSourceId("2"),
                         {value, 0.0, 0.0, 0.0, 0.0, 0.0},
                         {value, 2.0 * value, 3.0 * value, 4.0 * value}}};
  rows.gauss_rows = {{element,
                      1,
                      {value, value + 1.0, value + 2.0, value + 3.0},
                      {value, 2.0 * value, 3.0 * value, 4.0 * value}},
                     {element,
                      2,
                      {value + 4.0, value + 5.0, value + 6.0, value + 7.0},
                      {value + 8.0, value + 9.0, value + 10.0, value + 11.0}}};
  rows.stress_rows = {{element, 1, 0U, 0.0, 0.0, 5.0 * value, "fake"},
                      {element, 2, 1U, -0.25, 0.5, 6.0 * value, "input"}};
  return rows;
}

fesa::ShellElementResultRows MakeShellRows(const fesa::EntityIndex element,
                                           const double physical_energy) {
  const double gauss = 1.0 / std::sqrt(3.0);
  const std::array<fesa::ShellMidsurfaceLocation, 4> locations{
      fesa::ShellMidsurfaceLocation::kGp1, fesa::ShellMidsurfaceLocation::kGp2,
      fesa::ShellMidsurfaceLocation::kGp3, fesa::ShellMidsurfaceLocation::kGp4};
  const std::array<std::array<double, 2>, 4> coordinates{
      std::array<double, 2>{-gauss, -gauss},
      std::array<double, 2>{gauss, -gauss}, std::array<double, 2>{gauss, gauss},
      std::array<double, 2>{-gauss, gauss}};
  const std::array<fesa::ShellSectionPosition, 3> positions{
      fesa::ShellSectionPosition::kBottom, fesa::ShellSectionPosition::kMiddle,
      fesa::ShellSectionPosition::kTop};
  constexpr std::array<double, 3> zeta{-1.0, 0.0, 1.0};

  fesa::ShellElementResultRows rows{};
  rows.physical_strain_energy = physical_energy;
  for (std::size_t point = 0U; point < locations.size(); ++point) {
    fesa::ShellResultRow row{};
    row.element = element;
    row.location = locations[point];
    row.natural_coordinates = coordinates[point];
    row.local_frame = {{{1.0, 0.0, 0.0}, {0.0, 1.0, 0.0}, {0.0, 0.0, 1.0}}};
    for (std::size_t component = 0U; component < row.generalized_strain.size();
         ++component) {
      row.generalized_strain[component] =
          static_cast<double>(point + component + 1U);
      row.section_resultant[component] =
          10.0 * static_cast<double>(point + component + 1U);
    }
    for (std::size_t position = 0U; position < positions.size(); ++position) {
      row.stress[position] = {positions[position],
                              zeta[position],
                              {static_cast<double>(point + position + 1U),
                               static_cast<double>(point + position + 2U),
                               static_cast<double>(point + position + 3U)}};
    }
    rows.rows.push_back(std::move(row));
  }
  return rows;
}

fesa::ModelDefinition MakeShellDefinition() {
  const std::filesystem::path source{"models/recovery-components-shell.inp"};
  fesa::ModelDefinition definition{};
  definition.source_path = source;
  definition.source_content_identity = "fnv1a64:1234567890abcdef";
  definition.nodes = {{{"Shell-1", 1, "1"}, {-1.0, -1.0, 0.0}, {source, 10U}},
                      {{"Shell-1", 2, "2"}, {1.0, -1.0, 0.0}, {source, 11U}},
                      {{"Shell-1", 3, "3"}, {1.0, 1.0, 0.0}, {source, 12U}},
                      {{"Shell-1", 4, "4"}, {-1.0, 1.0, 0.0}, {source, 13U}}};
  definition.materials = {{"Material", 120.0, 0.25, {source, 20U}}};
  definition.shell_sections = {{"ShellSection", 2.0, 0U, {source, 30U}}};
  definition.shell_elements = {{{"Shell-1", 10, "10"},
                                fesa::ShellSourceElementType::kS4,
                                {0U, 1U, 2U, 3U},
                                0U,
                                0U,
                                {source, 40U}}};
  for (std::size_t node = 0U; node < definition.nodes.size(); ++node) {
    definition.shell_node_initial_frames.push_back(
        {static_cast<fesa::EntityIndex>(node),
         {0.0, 0.0, 1.0},
         {1.0, 0.0, 0.0},
         {0.0, 1.0, 0.0}});
  }
  definition.steps = {{"Step-1", {}, {}, 0.1, 1.0, 0.01, 1.0, {source, 50U}}};
  return definition;
}

ShellFixture MakeShellFixture(fesa::ModelDefinition definition) {
  auto domain_result = fesa::Domain::Create(std::move(definition));
  if (!domain_result.HasValue()) {
    throw std::runtime_error{"Shell Domain construction failed."};
  }
  auto domain =
      std::make_unique<fesa::Domain>(std::move(domain_result.Value()));

  auto model_result = fesa::AnalysisModel::Create(*domain);
  if (!model_result.HasValue()) {
    throw std::runtime_error{"Shell AnalysisModel construction failed."};
  }
  auto model =
      std::make_unique<fesa::AnalysisModel>(std::move(model_result.Value()));

  auto dofs_result = fesa::DofManager::Create(*model);
  if (!dofs_result.HasValue()) {
    throw std::runtime_error{"Shell DofManager construction failed."};
  }
  auto dofs =
      std::make_unique<fesa::DofManager>(std::move(dofs_result.Value()));

  fesa::SerialParallelFor serial;
  auto stiffness_result =
      fesa::SparseAssembler::AssembleStiffness(*model, *dofs, serial);
  if (!stiffness_result.HasValue()) {
    throw std::runtime_error{"Shell stiffness assembly failed."};
  }
  auto stiffness =
      std::make_unique<fesa::SparseMatrix>(std::move(stiffness_result.Value()));
  return {std::move(domain), std::move(model), std::move(dofs),
          std::move(stiffness)};
}

fesa::AnalysisState MakeShellPhysicalState(const ShellFixture& fixture) {
  constexpr std::array<double, 8> generalized{0.1,   -0.05, 0.2, 0.3,
                                              -0.15, 0.25,  0.4, -0.3};
  auto state = fesa::AnalysisState::Create(*fixture.dofs, {"Step-1", 0U});
  for (std::size_t node = 0U; node < fixture.domain->Nodes().size(); ++node) {
    const double x = fixture.domain->Nodes()[node].coordinates[0U];
    const double y = fixture.domain->Nodes()[node].coordinates[1U];
    const std::size_t offset = 6U * node;
    state.Displacement()[offset] =
        generalized[0U] * x + 0.5 * generalized[2U] * y;
    state.Displacement()[offset + 1U] =
        generalized[1U] * y + 0.5 * generalized[2U] * x;
    state.Displacement()[offset + 2U] = generalized[6U] * x +
                                        generalized[7U] * y -
                                        0.5 * generalized[5U] * x * y;
    state.Displacement()[offset + 3U] =
        -generalized[4U] * y - 0.5 * generalized[5U] * x;
    state.Displacement()[offset + 4U] =
        generalized[3U] * x + 0.5 * generalized[5U] * y;
  }
  state.ExternalForce() = fixture.stiffness->Multiply(state.Displacement());
  return state;
}

void ExpectStatusCode(const fesa::Status& status, const std::string& code) {
  ASSERT_FALSE(status.IsOk());
  EXPECT_EQ(status.Category(), fesa::FailureCategory::kModel);
  ASSERT_EQ(status.Diagnostics().size(), 1U);
  EXPECT_EQ(status.Diagnostics()[0U].code, code);
}

void ExpectVectorEqual(const fesa::Vector& actual,
                       const fesa::Vector& expected) {
  ASSERT_EQ(actual.Size(), expected.Size());
  for (std::size_t index = 0U; index < actual.Size(); ++index) {
    EXPECT_DOUBLE_EQ(actual[index], expected[index]);
  }
}

void ExpectAnalysisStateEqual(const fesa::AnalysisState& actual,
                              const fesa::AnalysisState& expected) {
  EXPECT_EQ(actual.Identity().step_name, expected.Identity().step_name);
  EXPECT_EQ(actual.Identity().frame_index, expected.Identity().frame_index);
  ExpectVectorEqual(actual.Displacement(), expected.Displacement());
  ExpectVectorEqual(actual.ExternalForce(), expected.ExternalForce());
  ExpectVectorEqual(actual.InternalForce(), expected.InternalForce());
  ExpectVectorEqual(actual.Residual(), expected.Residual());
  ExpectVectorEqual(actual.Reaction(), expected.Reaction());
  ASSERT_EQ(actual.EndpointResults().size(), expected.EndpointResults().size());
  for (std::size_t row = 0U; row < actual.EndpointResults().size(); ++row) {
    EXPECT_EQ(actual.EndpointResults()[row].element,
              expected.EndpointResults()[row].element);
    EXPECT_EQ(actual.EndpointResults()[row].endpoint,
              expected.EndpointResults()[row].endpoint);
    EXPECT_EQ(actual.EndpointResults()[row].node.instance_name,
              expected.EndpointResults()[row].node.instance_name);
    EXPECT_EQ(actual.EndpointResults()[row].node.source_label,
              expected.EndpointResults()[row].node.source_label);
    EXPECT_EQ(actual.EndpointResults()[row].node.source_label_text,
              expected.EndpointResults()[row].node.source_label_text);
    EXPECT_EQ(actual.EndpointResults()[row].end_action,
              expected.EndpointResults()[row].end_action);
    EXPECT_EQ(actual.EndpointResults()[row].section_resultant,
              expected.EndpointResults()[row].section_resultant);
  }
  ASSERT_EQ(actual.GaussResults().size(), expected.GaussResults().size());
  for (std::size_t row = 0U; row < actual.GaussResults().size(); ++row) {
    EXPECT_EQ(actual.GaussResults()[row].element,
              expected.GaussResults()[row].element);
    EXPECT_EQ(actual.GaussResults()[row].gauss_point,
              expected.GaussResults()[row].gauss_point);
    EXPECT_EQ(actual.GaussResults()[row].generalized_strain,
              expected.GaussResults()[row].generalized_strain);
    EXPECT_EQ(actual.GaussResults()[row].generalized_resultant,
              expected.GaussResults()[row].generalized_resultant);
  }
  ASSERT_EQ(actual.StressResults().size(), expected.StressResults().size());
  for (std::size_t row = 0U; row < actual.StressResults().size(); ++row) {
    EXPECT_EQ(actual.StressResults()[row].element,
              expected.StressResults()[row].element);
    EXPECT_EQ(actual.StressResults()[row].gauss_point,
              expected.StressResults()[row].gauss_point);
    EXPECT_EQ(actual.StressResults()[row].section_point,
              expected.StressResults()[row].section_point);
    EXPECT_DOUBLE_EQ(actual.StressResults()[row].x1,
                     expected.StressResults()[row].x1);
    EXPECT_DOUBLE_EQ(actual.StressResults()[row].x2,
                     expected.StressResults()[row].x2);
    EXPECT_DOUBLE_EQ(actual.StressResults()[row].s11,
                     expected.StressResults()[row].s11);
    EXPECT_EQ(actual.StressResults()[row].source,
              expected.StressResults()[row].source);
  }
  ASSERT_EQ(actual.ShellResults().size(), expected.ShellResults().size());
  for (std::size_t row = 0U; row < actual.ShellResults().size(); ++row) {
    EXPECT_EQ(actual.ShellResults()[row].element,
              expected.ShellResults()[row].element);
    EXPECT_EQ(actual.ShellResults()[row].location,
              expected.ShellResults()[row].location);
    EXPECT_EQ(actual.ShellResults()[row].natural_coordinates,
              expected.ShellResults()[row].natural_coordinates);
    EXPECT_EQ(actual.ShellResults()[row].local_frame,
              expected.ShellResults()[row].local_frame);
    EXPECT_EQ(actual.ShellResults()[row].generalized_strain,
              expected.ShellResults()[row].generalized_strain);
    EXPECT_EQ(actual.ShellResults()[row].section_resultant,
              expected.ShellResults()[row].section_resultant);
  }
  EXPECT_DOUBLE_EQ(actual.PhysicalStrainEnergy(),
                   expected.PhysicalStrainEnergy());
  EXPECT_EQ(actual.Equilibrium(), expected.Equilibrium());
  EXPECT_EQ(actual.VerificationMetrics(), expected.VerificationMetrics());
}

}  // namespace

// C-MODULE-002
TEST(ResultRecoveryComponents,
     GlobalEquilibriumUsesFullResidualAndGlobalOriginMoment) {
  auto centered_definition = MakeShellDefinition();
  auto translated_definition = centered_definition;
  constexpr fesa::Vector3 translation{7.0, 11.0, 0.0};
  for (auto& node : translated_definition.nodes) {
    for (std::size_t component = 0U;
         component < translation.Components().size(); ++component) {
      node.coordinates[component] += translation[component];
    }
  }
  const auto centered_fixture =
      MakeShellFixture(std::move(centered_definition));
  const auto translated_fixture =
      MakeShellFixture(std::move(translated_definition));
  auto centered = MakeShellPhysicalState(centered_fixture);
  auto translated = MakeShellPhysicalState(translated_fixture);
  centered.ExternalForce()[0U] += 1.0e-9;
  translated.ExternalForce()[0U] += 1.0e-9;

  auto centered_global = fesa::results_internal::GlobalEquilibriumRecovery(
      *centered_fixture.domain, *centered_fixture.dofs,
      *centered_fixture.stiffness, centered.Displacement(),
      centered.ExternalForce());
  ASSERT_TRUE(centered_global.HasValue());
  auto translated_global = fesa::results_internal::GlobalEquilibriumRecovery(
      *translated_fixture.domain, *translated_fixture.dofs,
      *translated_fixture.stiffness, translated.Displacement(),
      translated.ExternalForce());
  ASSERT_TRUE(translated_global.HasValue());
  EXPECT_NEAR(centered_global.Value().residual[0U], -1.0e-9, 1.0e-14);
  EXPECT_DOUBLE_EQ(centered_global.Value().reaction[0U],
                   centered_global.Value().residual[0U]);

  fesa::results_internal::RecoveryCandidate centered_candidate{
      centered_fixture.dofs->FullDofCount()};
  const auto centered_status =
      fesa::results_internal::RecoverShellGlobalEvidence(
          *centered_fixture.domain, *centered_fixture.dofs,
          centered.ExternalForce(), centered_global.Value(),
          centered_candidate);
  ASSERT_TRUE(centered_status.IsOk());
  fesa::results_internal::RecoveryCandidate translated_candidate{
      translated_fixture.dofs->FullDofCount()};
  const auto translated_status =
      fesa::results_internal::RecoverShellGlobalEvidence(
          *translated_fixture.domain, *translated_fixture.dofs,
          translated.ExternalForce(), translated_global.Value(),
          translated_candidate);
  ASSERT_TRUE(translated_status.IsOk());

  std::array<double, 3> centered_force{};
  for (std::size_t component = 0U; component < centered_force.size();
       ++component) {
    centered_force[component] = centered_candidate.shell.equilibrium[component];
    EXPECT_NEAR(translated_candidate.shell.equilibrium[component],
                centered_force[component], 1.0e-12);
  }
  const fesa::Vector3 translated_moment_delta =
      translation.Cross(fesa::Vector3{centered_force});
  for (std::size_t component = 0U; component < centered_force.size();
       ++component) {
    EXPECT_NEAR(translated_candidate.shell.equilibrium[3U + component] -
                    centered_candidate.shell.equilibrium[3U + component],
                translated_moment_delta[component], 5.0e-12);
  }
}

// C-MODULE-002
TEST(ResultRecoveryComponents,
     BeamResultRecoveryKeepsEndpointGaussAndStressIdentities) {
  constexpr fesa::EntityIndex element = 7U;
  const std::array<fesa::SourceEntityId, 2> expected_nodes{MakeSourceId("1"),
                                                           MakeSourceId("2")};
  fesa::results_internal::RecoveryCandidate candidate{0U};
  const auto status = fesa::results_internal::BeamResultRecovery(
      {}, MakeSourceId("10"), element, expected_nodes,
      MakeBeamRows(element, 2.0), candidate);

  ASSERT_TRUE(status.IsOk());
  ASSERT_EQ(candidate.endpoint_rows.size(), 2U);
  ASSERT_EQ(candidate.gauss_rows.size(), 2U);
  ASSERT_EQ(candidate.stress_rows.size(), 2U);
  EXPECT_TRUE(candidate.has_beam_results);
  EXPECT_EQ(candidate.endpoint_rows[0U].endpoint, 0);
  EXPECT_EQ(candidate.endpoint_rows[1U].endpoint, 1);
  EXPECT_DOUBLE_EQ(candidate.endpoint_rows[0U].end_action[0U], -2.0);
  EXPECT_DOUBLE_EQ(candidate.endpoint_rows[0U].section_resultant[0U], 2.0);
  EXPECT_DOUBLE_EQ(candidate.endpoint_rows[1U].end_action[0U], 2.0);
  EXPECT_DOUBLE_EQ(candidate.endpoint_rows[1U].section_resultant[0U], 2.0);
  EXPECT_EQ(candidate.gauss_rows[0U].gauss_point, 1);
  EXPECT_EQ(candidate.gauss_rows[1U].gauss_point, 2);
  EXPECT_EQ(candidate.stress_rows[0U].section_point, 0U);
  EXPECT_EQ(candidate.stress_rows[1U].section_point, 1U);

  auto invalid = MakeBeamRows(element, 3.0);
  invalid.stress_rows[1U].s11 = std::numeric_limits<double>::quiet_NaN();
  fesa::results_internal::RecoveryCandidate rejected{0U};
  ExpectStatusCode(
      fesa::results_internal::BeamResultRecovery(
          {}, MakeSourceId("10"), element, expected_nodes, invalid, rejected),
      "nonfinite-recovery-value");
  EXPECT_TRUE(rejected.endpoint_rows.empty());
  EXPECT_TRUE(rejected.gauss_rows.empty());
  EXPECT_TRUE(rejected.stress_rows.empty());
}

// C-MODULE-002
TEST(ResultRecoveryComponents,
     BeamResultRecoveryRejectsMalformedB33IdentityBeforeAppending) {
  constexpr fesa::EntityIndex element = 7U;
  const std::array<fesa::SourceEntityId, 2> expected_nodes{MakeSourceId("1"),
                                                           MakeSourceId("2")};
  std::vector<std::pair<std::string, fesa::BeamElementResultRows>> invalid;

  auto wrong_endpoint = MakeBeamRows(element, 1.0);
  wrong_endpoint.endpoint_rows[1U].endpoint = 2;
  invalid.emplace_back("wrong endpoint", std::move(wrong_endpoint));
  auto swapped_endpoints = MakeBeamRows(element, 1.0);
  std::swap(swapped_endpoints.endpoint_rows[0U],
            swapped_endpoints.endpoint_rows[1U]);
  invalid.emplace_back("swapped endpoints", std::move(swapped_endpoints));
  auto missing_endpoint = MakeBeamRows(element, 1.0);
  missing_endpoint.endpoint_rows.pop_back();
  invalid.emplace_back("missing endpoint", std::move(missing_endpoint));
  auto duplicate_endpoint = MakeBeamRows(element, 1.0);
  duplicate_endpoint.endpoint_rows[1U] = duplicate_endpoint.endpoint_rows[0U];
  invalid.emplace_back("duplicate endpoint", std::move(duplicate_endpoint));
  auto wrong_source_node = MakeBeamRows(element, 1.0);
  wrong_source_node.endpoint_rows[0U].node = MakeSourceId("99");
  invalid.emplace_back("wrong source node", std::move(wrong_source_node));

  auto wrong_gauss = MakeBeamRows(element, 1.0);
  wrong_gauss.gauss_rows[1U].gauss_point = 3;
  invalid.emplace_back("wrong GP", std::move(wrong_gauss));
  auto swapped_gauss = MakeBeamRows(element, 1.0);
  std::swap(swapped_gauss.gauss_rows[0U], swapped_gauss.gauss_rows[1U]);
  invalid.emplace_back("swapped GP", std::move(swapped_gauss));
  auto missing_gauss = MakeBeamRows(element, 1.0);
  missing_gauss.gauss_rows.pop_back();
  invalid.emplace_back("missing GP", std::move(missing_gauss));
  auto duplicate_gauss = MakeBeamRows(element, 1.0);
  duplicate_gauss.gauss_rows[1U] = duplicate_gauss.gauss_rows[0U];
  invalid.emplace_back("duplicate GP", std::move(duplicate_gauss));

  auto malformed_stress_order = MakeBeamRows(element, 1.0);
  std::swap(malformed_stress_order.stress_rows[0U],
            malformed_stress_order.stress_rows[1U]);
  invalid.emplace_back("malformed stress order",
                       std::move(malformed_stress_order));

  for (const auto& [description, rows] : invalid) {
    SCOPED_TRACE(description);
    fesa::results_internal::RecoveryCandidate candidate{0U};
    ExpectStatusCode(
        fesa::results_internal::BeamResultRecovery(
            {}, MakeSourceId("10"), element, expected_nodes, rows, candidate),
        "invalid-element-result-identity");
    EXPECT_TRUE(candidate.endpoint_rows.empty());
    EXPECT_TRUE(candidate.gauss_rows.empty());
    EXPECT_TRUE(candidate.stress_rows.empty());
    EXPECT_FALSE(candidate.has_beam_results);
  }
}

// C-MODULE-002
TEST(ResultRecoveryComponents,
     ShellResultRecoveryKeepsGpStressOrderAndPhysicalEnergy) {
  constexpr fesa::EntityIndex element = 4U;
  fesa::results_internal::RecoveryCandidate candidate{0U};
  const auto status = fesa::results_internal::ShellResultRecovery(
      {}, MakeSourceId("20"), element, MakeShellRows(element, 12.5), candidate);

  ASSERT_TRUE(status.IsOk());
  EXPECT_TRUE(candidate.has_shell_results);
  EXPECT_EQ(candidate.expected_shell_elements,
            (std::vector<fesa::EntityIndex>{element}));
  ASSERT_EQ(candidate.shell.rows.size(), 4U);
  EXPECT_EQ(candidate.shell.rows[0U].location,
            fesa::ShellMidsurfaceLocation::kGp1);
  EXPECT_EQ(candidate.shell.rows[3U].location,
            fesa::ShellMidsurfaceLocation::kGp4);
  EXPECT_EQ(candidate.shell.rows[0U].stress[0U].position,
            fesa::ShellSectionPosition::kBottom);
  EXPECT_EQ(candidate.shell.rows[0U].stress[1U].position,
            fesa::ShellSectionPosition::kMiddle);
  EXPECT_EQ(candidate.shell.rows[0U].stress[2U].position,
            fesa::ShellSectionPosition::kTop);
  EXPECT_DOUBLE_EQ(candidate.shell.physical_strain_energy, 12.5);

  auto invalid = MakeShellRows(element, 12.5);
  invalid.rows[2U].element = element + 1U;
  fesa::results_internal::RecoveryCandidate rejected{0U};
  ExpectStatusCode(fesa::results_internal::ShellResultRecovery(
                       {}, MakeSourceId("20"), element, invalid, rejected),
                   "invalid-element-result-identity");
  EXPECT_TRUE(rejected.shell.rows.empty());
  EXPECT_TRUE(rejected.expected_shell_elements.empty());
  EXPECT_DOUBLE_EQ(rejected.shell.physical_strain_energy, 0.0);
}

// C-MODULE-002
TEST(ResultRecoveryComponents,
     CommitRecoveryCandidateRollsBackLaterInvalidShellBundle) {
  const auto fixture = MakeShellFixture(MakeShellDefinition());
  auto state = fesa::AnalysisState::Create(*fixture.dofs, {"Step-1", 0U});
  for (std::size_t full_dof = 0U; full_dof < fixture.dofs->FullDofCount();
       ++full_dof) {
    state.Displacement()[full_dof] = static_cast<double>(full_dof) + 0.25;
    state.ExternalForce()[full_dof] = -static_cast<double>(full_dof) - 0.5;
    state.InternalForce()[full_dof] = 100.0 + static_cast<double>(full_dof);
    state.Residual()[full_dof] = 200.0 + static_cast<double>(full_dof);
    state.Reaction()[full_dof] = 300.0 + static_cast<double>(full_dof);
  }
  state.EndpointResults() = MakeBeamRows(0U, 9.0).endpoint_rows;
  auto prior_shell_rows = MakeShellRows(0U, 71.0);
  fesa::ShellStateCandidate prior_shell{};
  prior_shell.rows = prior_shell_rows.rows;
  prior_shell.physical_strain_energy = prior_shell_rows.physical_strain_energy;
  prior_shell.equilibrium = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0};
  prior_shell.verification_metrics = {1.0e-11, 2.0e-11, 3.0e-11};
  ASSERT_TRUE(state.CommitShellResults({0U}, std::move(prior_shell)).IsOk());
  const fesa::AnalysisState prior = state;

  fesa::results_internal::RecoveryCandidate candidate{
      fixture.dofs->FullDofCount()};
  for (std::size_t full_dof = 0U; full_dof < fixture.dofs->FullDofCount();
       ++full_dof) {
    candidate.displacement[full_dof] = 10.0 + static_cast<double>(full_dof);
    candidate.external_force[full_dof] = 20.0 + static_cast<double>(full_dof);
    candidate.internal_force[full_dof] = 30.0 + static_cast<double>(full_dof);
    candidate.residual[full_dof] = 40.0 + static_cast<double>(full_dof);
    candidate.reaction[full_dof] = 50.0 + static_cast<double>(full_dof);
  }
  candidate.has_shell_results = true;
  candidate.expected_shell_elements = {0U};
  auto invalid_shell_rows = MakeShellRows(0U, 12.5);
  candidate.shell.rows = invalid_shell_rows.rows;
  candidate.shell.rows[3U].location = fesa::ShellMidsurfaceLocation::kGp1;
  candidate.shell.physical_strain_energy =
      invalid_shell_rows.physical_strain_energy;
  candidate.shell.equilibrium = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
  candidate.shell.verification_metrics = {0.0, 0.0, 0.0};

  const auto status = fesa::results_internal::CommitRecoveryCandidate(
      std::move(candidate), state);

  ExpectStatusCode(status, "invalid-shell-state-inventory");
  ExpectVectorEqual(state.Displacement(), prior.Displacement());
  ExpectVectorEqual(state.ExternalForce(), prior.ExternalForce());
  ExpectVectorEqual(state.InternalForce(), prior.InternalForce());
  ExpectVectorEqual(state.Residual(), prior.Residual());
  ExpectVectorEqual(state.Reaction(), prior.Reaction());
  ASSERT_EQ(state.EndpointResults().size(), prior.EndpointResults().size());
  EXPECT_EQ(state.EndpointResults()[0U].end_action,
            prior.EndpointResults()[0U].end_action);
  ASSERT_EQ(state.ShellResults().size(), prior.ShellResults().size());
  EXPECT_EQ(state.ShellResults()[0U].location,
            prior.ShellResults()[0U].location);
  EXPECT_EQ(state.ShellResults()[0U].section_resultant,
            prior.ShellResults()[0U].section_resultant);
  EXPECT_DOUBLE_EQ(state.PhysicalStrainEnergy(), prior.PhysicalStrainEnergy());
  EXPECT_EQ(state.Equilibrium(), prior.Equilibrium());
  EXPECT_EQ(state.VerificationMetrics(), prior.VerificationMetrics());
}

// C-MODULE-002
TEST(ResultRecoveryComponents,
     CommitRecoveryCandidateRejectsNonfiniteVectorAndPreservesWholeState) {
  const auto fixture = MakeShellFixture(MakeShellDefinition());
  auto state = fesa::AnalysisState::Create(*fixture.dofs, {"Prior-Step", 3U});
  for (std::size_t full_dof = 0U; full_dof < fixture.dofs->FullDofCount();
       ++full_dof) {
    state.Displacement()[full_dof] = static_cast<double>(full_dof) + 0.25;
    state.ExternalForce()[full_dof] = -static_cast<double>(full_dof) - 0.5;
    state.InternalForce()[full_dof] = 100.0 + static_cast<double>(full_dof);
    state.Residual()[full_dof] = 200.0 + static_cast<double>(full_dof);
    state.Reaction()[full_dof] = 300.0 + static_cast<double>(full_dof);
  }
  const auto prior_beam = MakeBeamRows(0U, 9.0);
  state.EndpointResults() = prior_beam.endpoint_rows;
  state.GaussResults() = prior_beam.gauss_rows;
  state.StressResults() = prior_beam.stress_rows;
  auto prior_shell_rows = MakeShellRows(0U, 71.0);
  fesa::ShellStateCandidate prior_shell{};
  prior_shell.rows = prior_shell_rows.rows;
  prior_shell.physical_strain_energy = prior_shell_rows.physical_strain_energy;
  prior_shell.equilibrium = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0};
  prior_shell.verification_metrics = {1.0e-11, 2.0e-11, 3.0e-11};
  ASSERT_TRUE(state.CommitShellResults({0U}, std::move(prior_shell)).IsOk());
  const fesa::AnalysisState prior = state;

  fesa::results_internal::RecoveryCandidate candidate{
      fixture.dofs->FullDofCount()};
  candidate.displacement[0U] = 10.0;
  candidate.external_force[0U] = 20.0;
  candidate.internal_force[0U] = 30.0;
  candidate.residual[0U] = 40.0;
  candidate.reaction[0U] = std::numeric_limits<double>::quiet_NaN();

  const auto status = fesa::results_internal::CommitRecoveryCandidate(
      std::move(candidate), state);

  ExpectStatusCode(status, "nonfinite-recovery-value");
  ExpectAnalysisStateEqual(state, prior);
}