#include "io/abaqus/step_definition_mapper.h"

#include <algorithm>
#include <cerrno>
#include <charconv>
#include <cmath>
#include <cstdlib>
#include <limits>
#include <map>
#include <system_error>
#include <utility>

#include "fesa/analysis/thermal_time_grid.h"
#include "fesa/core/ascii.h"
#include "io/abaqus/domain_mapping_context.h"
#include "io/abaqus/step_definition_candidates.h"
#include "io/abaqus/surface_definition_candidates.h"

namespace fesa::abaqus_internal {

bool StepDefinitionCandidates::HasSupportedProcedure() const noexcept {
  return step_.has_static || step_.frequency || step_.dynamic ||
         step_.has_heat_transfer;
}

void StepDefinitionCandidates::FillSummary(
    DomainMappingCandidateSummary& summary) const noexcept {
  summary.model_boundary_count = model_boundaries_.size();
  summary.step_boundary_count = step_.boundaries.size();
  summary.step_load_count = step_.loads.size();
  summary.has_static_step = step_.has_static;
}

MaterialProcedureView StepDefinitionCandidates::MaterialProcedure(
    std::optional<MaterialProcedureView::Surface> first_surface,
    const std::optional<SourceLocation>& physical_constants) const {
  return {step_.frequency.has_value(),
          step_.dynamic.has_value(),
          step_.location,
          step_.name_raw,
          std::move(first_surface),
          physical_constants};
}

void StepDefinitionCandidates::ParseModelBoundary(const KeywordBlock& block) {
  if (model_element_family_ == ElementFamily::kThermalShell) {
    ParseThermalBoundary(block, thermal_model_boundaries_);
  } else {
    ParseBoundary(block, model_boundaries_);
  }
}

bool StepDefinitionCandidates::ParseSurfacePressureDouble(
    const std::string& text, double& value, const SourceLocation& location,
    const std::string& keyword) {
  std::size_t cursor = 0U;
  if (cursor < text.size() && (text[cursor] == '+' || text[cursor] == '-')) {
    ++cursor;
  }
  const std::size_t integer_start = cursor;
  while (cursor < text.size() && text[cursor] >= '0' && text[cursor] <= '9') {
    ++cursor;
  }
  const bool has_integer_digits = cursor != integer_start;
  bool has_fraction_digits = false;
  if (cursor < text.size() && text[cursor] == '.') {
    ++cursor;
    const std::size_t fraction_start = cursor;
    while (cursor < text.size() && text[cursor] >= '0' && text[cursor] <= '9') {
      ++cursor;
    }
    has_fraction_digits = cursor != fraction_start;
  }
  if (!has_integer_digits && !has_fraction_digits) {
    return diagnostics_.InputFailure(
        "invalid-numeric-value", location, keyword, text,
        "Pressure values require C-locale decimal syntax.");
  }
  if (cursor < text.size() && (text[cursor] == 'E' || text[cursor] == 'e')) {
    ++cursor;
    if (cursor < text.size() && (text[cursor] == '+' || text[cursor] == '-')) {
      ++cursor;
    }
    const std::size_t exponent_start = cursor;
    while (cursor < text.size() && text[cursor] >= '0' && text[cursor] <= '9') {
      ++cursor;
    }
    if (cursor == exponent_start) {
      return diagnostics_.InputFailure(
          "invalid-numeric-value", location, keyword, text,
          "Pressure exponents require one or more digits.");
    }
  }
  if (cursor != text.size()) {
    return diagnostics_.InputFailure(
        "invalid-numeric-value", location, keyword, text,
        "Pressure values require C-locale decimal syntax.");
  }
  const char* const begin = text.data();
  const char* const end = begin + text.size();
  const char* const numeric_begin = *begin == '+' ? begin + 1U : begin;
  const auto parsed =
      std::from_chars(numeric_begin, end, value, std::chars_format::general);
  if (parsed.ec != std::errc{} || parsed.ptr != end || !std::isfinite(value)) {
    return diagnostics_.InputFailure(
        "invalid-numeric-value", location, keyword, text,
        "Pressure values must be finite C-locale values.");
  }
  return true;
}

bool StepDefinitionCandidates::ParseNonlinearStaticDouble(
    const std::string& text, double& value, const SourceLocation& location,
    const std::string& keyword) {
  if (text.empty()) {
    return diagnostics_.InputFailure(
        "invalid-nonlinear-static-data", location, keyword, text,
        "A nonlinear STATIC field cannot be empty.");
  }
  char* end = nullptr;
  errno = 0;
  const double parsed = std::strtod(text.c_str(), &end);
  if (errno == ERANGE || end != text.c_str() + text.size() ||
      !std::isfinite(parsed)) {
    return diagnostics_.InputFailure(
        "invalid-nonlinear-static-data", location, keyword, text,
        "All four nonlinear STATIC fields must be finite.");
  }
  value = parsed;
  return true;
}

bool StepDefinitionCandidates::ParseDynamicDouble(
    const std::string& text, double& value, const SourceLocation& location,
    const std::string& keyword) {
  if (text.empty()) {
    return diagnostics_.InputFailure("invalid-dynamic-data", location, keyword,
                                     text,
                                     "Dynamic data fields cannot be empty.");
  }
  char* end = nullptr;
  errno = 0;
  const double parsed = std::strtod(text.c_str(), &end);
  if (errno == ERANGE || end != text.c_str() + text.size() ||
      !std::isfinite(parsed)) {
    return diagnostics_.InputFailure("invalid-dynamic-data", location, keyword,
                                     text,
                                     "Dynamic data fields must be finite.");
  }
  value = parsed;
  return true;
}

void StepDefinitionCandidates::ParseAmplitude(const KeywordBlock& block) {
  const bool dynamic_source = std::any_of(
      input_.blocks.begin(), input_.blocks.end(), [](const auto& candidate) {
        return candidate.canonical_name == "DYNAMIC";
      });
  if (model_element_family_ != ElementFamily::kSolid || !dynamic_source) {
    diagnostics_.InputFailure(
        "unsupported-load-amplitude", block.location, block.canonical_name, "",
        "Amplitude is supported only in Solid dynamic models.");
    return;
  }
  if (!diagnostics_.ValidateParameters(block,
                                       {"NAME", "DEFINITION", "TIME", "VALUE"}))
    return;
  const auto* name = diagnostics_.RequiredParameterValue(block, "NAME");
  if (!name) return;
  for (const auto& option : std::array<std::pair<const char*, const char*>, 3>{
           {{"DEFINITION", "TABULAR"},
            {"TIME", "STEP TIME"},
            {"VALUE", "RELATIVE"}}}) {
    const auto* parameter = diagnostics_.Parameter(block, option.first);
    if (parameter &&
        (!parameter->value ||
         !AsciiCaseInsensitiveEquals(*parameter->value, option.second))) {
      diagnostics_.InputFailure(
          "unsupported-amplitude-option", block.location, block.canonical_name,
          option.first,
          "Only TABULAR STEP TIME RELATIVE amplitude is supported.");
      return;
    }
  }
  const std::string canonical = AsciiUppercase(*name);
  if (std::any_of(definition_.amplitudes.begin(), definition_.amplitudes.end(),
                  [&canonical](const auto& a) {
                    return a.name_canonical == canonical;
                  })) {
    diagnostics_.InputFailure(
        "duplicate-amplitude", block.location, block.canonical_name, *name,
        "Amplitude names must be unique ignoring ASCII case.");
    return;
  }
  TabularAmplitudeDefinition amplitude{*name, canonical, block.location, {}};
  for (const auto& row : block.data) {
    if (row.fields.empty() || row.fields.size() % 2U != 0U) {
      diagnostics_.InputFailure(
          "invalid-amplitude-data", row.location, block.canonical_name, *name,
          "Amplitude rows require complete time/value pairs.");
      return;
    }
    for (std::size_t field = 0U; field < row.fields.size(); field += 2U) {
      double time = 0.0;
      double value = 0.0;
      if (!diagnostics_.ParseDouble(row.fields[field], time, row.location,
                                    block.canonical_name) ||
          !diagnostics_.ParseDouble(row.fields[field + 1U], value, row.location,
                                    block.canonical_name))
        return;
      if (time < 0.0 ||
          (!amplitude.points.empty() && !(time > amplitude.points.back()[0]))) {
        diagnostics_.InputFailure(
            "invalid-amplitude-data", row.location, block.canonical_name, *name,
            "Amplitude times must be nonnegative and strictly increasing.");
        return;
      }
      amplitude.points.push_back({time, value});
    }
  }
  if (amplitude.points.empty()) {
    diagnostics_.InputFailure(
        "invalid-amplitude-data", block.location, block.canonical_name, *name,
        "Amplitude requires at least one finite time/value pair.");
    return;
  }
  definition_.amplitudes.push_back(std::move(amplitude));
}

void StepDefinitionCandidates::ParseInitialConditions(
    const KeywordBlock& block) {
  if (model_element_family_ != ElementFamily::kThermalShell ||
      !diagnostics_.ValidateParameters(block, {"TYPE"}) || block.data.empty()) {
    if (!diagnostics_.HasFailure()) {
      diagnostics_.InputFailure(
          "invalid-data-arity", block.location, block.canonical_name, "",
          "Thermal initial conditions require data rows.");
    }
    return;
  }
  const auto* type = diagnostics_.RequiredParameterValue(block, "TYPE");
  if (type == nullptr || !AsciiCaseInsensitiveEquals(*type, "TEMPERATURE")) {
    if (!diagnostics_.HasFailure())
      diagnostics_.InputFailure("unsupported-keyword", block.location,
                                block.canonical_name, "TYPE",
                                "Only TYPE=TEMPERATURE is supported.");
    return;
  }
  for (const auto& row : block.data) {
    if (row.fields.size() != 2U || row.fields[0].empty()) {
      diagnostics_.InputFailure("invalid-data-arity", row.location,
                                block.canonical_name, "",
                                "Initial temperatures require target, value.");
      return;
    }
    double value = 0.0;
    if (!diagnostics_.ParseThermalDouble(row.fields[1], value, row.location,
                                         block.canonical_name))
      return;
    thermal_initial_conditions_.push_back({row.fields[0], value, row.location});
  }
}

void StepDefinitionCandidates::ParseThermalBoundary(
    const KeywordBlock& block, std::vector<RawThermalBoundary>& destination) {
  if (!diagnostics_.ValidateParameters(block, {}) || block.data.empty()) {
    if (!diagnostics_.HasFailure())
      diagnostics_.InputFailure("invalid-data-arity", block.location,
                                block.canonical_name, "",
                                "Thermal BOUNDARY requires data rows.");
    return;
  }
  for (const auto& row : block.data) {
    if ((row.fields.size() != 3U && row.fields.size() != 4U) ||
        row.fields[0].empty()) {
      diagnostics_.InputFailure(
          "invalid-data-arity", row.location, block.canonical_name, "",
          "Thermal boundaries require target, DOF, DOF, value.");
      return;
    }
    std::int64_t first = 0;
    std::int64_t last = 0;
    if (!diagnostics_.ParseInteger(row.fields[1], first, row.location,
                                   block.canonical_name, true) ||
        !diagnostics_.ParseInteger(row.fields[2], last, row.location,
                                   block.canonical_name, true) ||
        first != last || (first != 11 && first != 15)) {
      diagnostics_.InputFailure("invalid-dof", row.location,
                                block.canonical_name, row.fields[0],
                                "Thermal boundaries support DOF 11 or 15.");
      return;
    }
    double value = 0.0;
    if (row.fields.size() == 4U &&
        !diagnostics_.ParseThermalDouble(row.fields[3], value, row.location,
                                         block.canonical_name))
      return;
    destination.push_back(
        {row.fields[0], static_cast<int>(first), value, row.location});
  }
}

void StepDefinitionCandidates::ParseBoundary(
    const KeywordBlock& block,
    std::vector<PrescribedDisplacementDefinition>& destination) {
  const bool dynamic_input = std::any_of(
      input_.blocks.begin(), input_.blocks.end(), [](const auto& candidate) {
        return candidate.canonical_name == "DYNAMIC";
      });
  if (!diagnostics_.ValidateParameters(block, {},
                                       dynamic_input
                                           ? "unsupported-dynamic-boundary"
                                           : "invalid-keyword-parameter") ||
      block.data.empty()) {
    if (!diagnostics_.HasFailure()) {
      diagnostics_.InputFailure("invalid-data-arity", block.location,
                                block.canonical_name, "",
                                "BOUNDARY requires one or more data rows.");
    }
    return;
  }
  for (const auto& row : block.data) {
    if (row.fields.size() != 3U && row.fields.size() != 4U) {
      diagnostics_.InputFailure(
          "invalid-data-arity", row.location, block.canonical_name, "",
          "BOUNDARY rows require target, first DOF, last DOF, and "
          "optional value.");
      return;
    }
    if (row.fields[0].empty()) {
      diagnostics_.InputFailure("unresolved-reference", row.location,
                                block.canonical_name, "",
                                "A boundary target cannot be empty.");
      return;
    }
    std::int64_t first = 0;
    std::int64_t last = 0;
    if (!diagnostics_.ParseInteger(row.fields[1], first, row.location,
                                   block.canonical_name, true) ||
        !diagnostics_.ParseInteger(row.fields[2], last, row.location,
                                   block.canonical_name, true)) {
      return;
    }
    if (first < 1 || first > 6 || last < first || last > 6) {
      diagnostics_.InputFailure(
          "invalid-dof", row.location, block.canonical_name, row.fields[0],
          "Boundary DOFs must be an ordered range in 1..6.");
      return;
    }
    double value = 0.0;
    if (row.fields.size() == 4U &&
        !(model_element_family_ == ElementFamily::kSolid &&
          row.fields[3].empty()) &&
        !diagnostics_.ParseDouble(row.fields[3], value, row.location,
                                  block.canonical_name)) {
      return;
    }
    destination.push_back({row.fields[0], static_cast<int>(first),
                           static_cast<int>(last), value, row.location});
  }
}

void StepDefinitionCandidates::ParseCload(const KeywordBlock& block,
                                          std::vector<NodalLoad>& loads) {
  if (step_.dynamic && model_element_family_ != ElementFamily::kSolid &&
      !block.parameters.empty()) {
    diagnostics_.InputFailure(
        "unsupported-dynamic-load", block.location, block.canonical_name, "",
        "Dynamic CLOAD does not support keyword parameters.");
    return;
  }
  const bool solid_dynamic =
      step_.dynamic && model_element_family_ == ElementFamily::kSolid;
  if (!diagnostics_.ValidateParameters(
          block, solid_dynamic ? std::vector<std::string_view>{"AMPLITUDE"}
                               : std::vector<std::string_view>{}) ||
      block.data.empty()) {
    if (!diagnostics_.HasFailure()) {
      diagnostics_.InputFailure("invalid-data-arity", block.location,
                                block.canonical_name, "",
                                "CLOAD requires one or more rows.");
    }
    return;
  }
  std::optional<EntityIndex> amplitude_index;
  std::string amplitude_name;
  if (diagnostics_.Parameter(block, "AMPLITUDE")) {
    const auto* name = diagnostics_.RequiredParameterValue(block, "AMPLITUDE");
    if (!name) return;
    amplitude_name = *name;
    for (std::size_t index = 0U; index < definition_.amplitudes.size();
         ++index) {
      if (AsciiCaseInsensitiveEquals(definition_.amplitudes[index].name_raw,
                                     *name)) {
        amplitude_index = static_cast<EntityIndex>(index);
        break;
      }
    }
    if (!amplitude_index) {
      diagnostics_.InputFailure(
          "unresolved-amplitude", block.location, block.canonical_name, *name,
          "CLOAD amplitude must resolve to a model-level curve.");
      return;
    }
  }
  for (const auto& row : block.data) {
    if (row.fields.size() != 3U || row.fields[0].empty()) {
      diagnostics_.InputFailure("invalid-data-arity", row.location,
                                block.canonical_name, "",
                                "CLOAD rows require target, DOF, magnitude.");
      return;
    }
    std::int64_t dof = 0;
    double magnitude = 0.0;
    if (!diagnostics_.ParseInteger(row.fields[1], dof, row.location,
                                   block.canonical_name, true) ||
        !diagnostics_.ParseDouble(row.fields[2], magnitude, row.location,
                                  block.canonical_name)) {
      return;
    }
    if (dof < 1 || dof > 6) {
      diagnostics_.InputFailure("invalid-dof", row.location,
                                block.canonical_name, row.fields[0],
                                "CLOAD DOF must be in 1..6.");
      return;
    }
    if ((step_.dynamic || model_element_family_ == ElementFamily::kSolid) &&
        dof > 3) {
      diagnostics_.InputFailure(
          "unsupported-dynamic-load", row.location, block.canonical_name,
          row.fields[1],
          "Dynamic CLOAD supports global translational DOF 1 "
          "through 3 only.");
      return;
    }
    loads.push_back({row.fields[0], static_cast<int>(dof), magnitude,
                     row.location, amplitude_index, amplitude_name,
                     block.location});
  }
}

void StepDefinitionCandidates::ParseDsload(const KeywordBlock& block) {
  if (!diagnostics_.ValidateParameters(block, {},
                                       "unsupported-dsload-parameter") ||
      block.data.empty()) {
    if (!diagnostics_.HasFailure()) {
      diagnostics_.InputFailure("invalid-data-arity", block.location,
                                block.canonical_name, "",
                                "DSLOAD requires one or more rows.");
    }
    return;
  }
  for (std::size_t ordinal = 0U; ordinal < block.data.size(); ++ordinal) {
    const auto& row = block.data[ordinal];
    if (row.fields.size() != 3U || row.fields[0].empty() ||
        row.fields[1].empty() || row.fields[2].empty()) {
      diagnostics_.InputFailure("invalid-data-arity", row.location,
                                block.canonical_name, "",
                                "DSLOAD rows require surface, P, magnitude.");
      return;
    }
    if (!IsPressureNameToken(row.fields[0])) {
      diagnostics_.InputFailure(
          "invalid-surface-name", row.location, block.canonical_name,
          row.fields[0],
          "DSLOAD surface names must use the approved ASCII name "
          "syntax.");
      return;
    }
    if (!AsciiCaseInsensitiveEquals(row.fields[1], "P")) {
      diagnostics_.InputFailure(
          "unsupported-load-type", row.location, block.canonical_name,
          row.fields[1],
          "Only uniform surface pressure load type P is supported.");
      return;
    }
    double magnitude = 0.0;
    if (!ParseSurfacePressureDouble(row.fields[2], magnitude, row.location,
                                    block.canonical_name)) {
      return;
    }
    step_.surface_pressure_loads.push_back(
        {row.fields[0], magnitude, row.fields[2], block.location, row.location,
         ordinal, step_.next_load_ordinal++});
  }
}

void StepDefinitionCandidates::ParseStepStart(const KeywordBlock& block,
                                              bool model_ready) {
  if (step_seen_) {
    if (step_.frequency || step_.dynamic) {
      diagnostics_.InputFailure(
          "unsupported-analysis-procedure", block.location,
          block.canonical_name, "",
          "The frequency subset accepts exactly one procedure step.");
    } else {
      const auto* nlgeom = diagnostics_.Parameter(block, "NLGEOM");
      const bool nonlinear_second_step =
          nlgeom != nullptr && nlgeom->value &&
          AsciiCaseInsensitiveEquals(*nlgeom->value, "YES");
      if (step_.nlgeom || nonlinear_second_step) {
        diagnostics_.InputFailure(
            "unsupported-analysis-procedure", block.location,
            block.canonical_name, "",
            "The nonlinear static subset accepts exactly one "
            "procedure step.");
      } else {
        diagnostics_.InputFailure("unsupported-multiple-step", block.location,
                                  block.canonical_name, "",
                                  "V0 accepts exactly one analysis step.");
      }
    }
    return;
  }
  if (!model_ready) {
    diagnostics_.InvalidKeywordLocation(
        block,
        "The sole step follows the complete assembly and "
        "material definitions.");
    return;
  }
  if (!diagnostics_.ValidateParameters(
          block, {"NAME", "NLGEOM", "PERTURBATION", "INC"}) ||
      !diagnostics_.RequireNoData(block)) {
    return;
  }
  StaticProcedureKind procedure_kind =
      StaticProcedureKind::kLinearSmallDisplacement;
  bool nlgeom = false;
  const auto* nlgeom_parameter = diagnostics_.Parameter(block, "NLGEOM");
  if (nlgeom_parameter != nullptr) {
    if (!nlgeom_parameter->value || nlgeom_parameter->value->empty()) {
      diagnostics_.InputFailure(
          "invalid-keyword-parameter", block.location, block.canonical_name,
          "NLGEOM", "NLGEOM requires YES or NO in the approved subset.");
      return;
    }
    if (AsciiCaseInsensitiveEquals(*nlgeom_parameter->value, "YES")) {
      if (model_element_family_ != ElementFamily::kShell &&
          model_element_family_ != ElementFamily::kSolid) {
        diagnostics_.InputFailure(
            "unsupported-analysis-procedure", block.location,
            block.canonical_name, *nlgeom_parameter->value,
            "NLGEOM=YES requires a supported Shell or Solid model.");
        return;
      }
      procedure_kind = StaticProcedureKind::kNonlinearFullNewton;
      nlgeom = true;
    } else if (!AsciiCaseInsensitiveEquals(*nlgeom_parameter->value, "NO")) {
      diagnostics_.InputFailure("unsupported-analysis-procedure",
                                block.location, block.canonical_name,
                                *nlgeom_parameter->value,
                                "NLGEOM must select YES or NO.");
      return;
    }
  }
  const auto* perturbation = diagnostics_.Parameter(block, "PERTURBATION");
  if (perturbation != nullptr && perturbation->value) {
    diagnostics_.InputFailure(
        "unsupported-analysis-procedure", block.location, block.canonical_name,
        "PERTURBATION", "PERTURBATION is accepted only as a value-less flag.");
    return;
  }
  const auto* name = diagnostics_.Parameter(block, "NAME");
  if (name != nullptr && (!name->value || name->value->empty())) {
    diagnostics_.InputFailure(
        "invalid-keyword-parameter", block.location, block.canonical_name,
        "NAME", "STEP NAME must not be empty when it is present.");
    return;
  }
  const auto* increment_limit = diagnostics_.Parameter(block, "INC");
  std::uint32_t maximum_increments = 100U;
  if (increment_limit != nullptr) {
    if (!increment_limit->value || increment_limit->value->empty()) {
      diagnostics_.InputFailure("invalid-dynamic-data", block.location,
                                block.canonical_name, "INC",
                                "INC requires a positive uint32 value.");
      return;
    }
    std::int64_t parsed_limit = 0;
    if (!diagnostics_.ParseInteger(*increment_limit->value, parsed_limit,
                                   block.location, block.canonical_name,
                                   true) ||
        parsed_limit > static_cast<std::int64_t>(
                           std::numeric_limits<std::uint32_t>::max())) {
      if (!diagnostics_.HasFailure()) {
        diagnostics_.InputFailure("invalid-dynamic-data", block.location,
                                  block.canonical_name, "INC",
                                  "INC requires a positive uint32 value.");
      }
      return;
    }
    maximum_increments = static_cast<std::uint32_t>(parsed_limit);
  }
  step_seen_ = true;
  in_step_ = true;
  step_ = {};
  step_.location = block.location;
  step_.name_raw = name == nullptr ? "Step-1" : *name->value;
  step_.name_canonical = AsciiUppercase(step_.name_raw);
  step_.procedure_kind = procedure_kind;
  step_.nlgeom = nlgeom;
  step_.nlgeom_explicit = nlgeom_parameter != nullptr;
  step_.perturbation_explicit = perturbation != nullptr;
  step_.maximum_increments = maximum_increments;
  step_load_seen_ = false;
  step_no_op_seen_ = false;
}

void StepDefinitionCandidates::ParseStepBlock(const KeywordBlock& block) {
  if (model_element_family_ == ElementFamily::kSolid &&
      (block.canonical_name == "STATIC" ||
       block.canonical_name == "FREQUENCY" ||
       block.canonical_name == "DYNAMIC") &&
      (step_.has_static || step_.frequency || step_.dynamic)) {
    diagnostics_.InputFailure("unsupported-analysis-procedure", block.location,
                              block.canonical_name, step_.name_raw,
                              "Solid steps accept exactly one procedure.");
    return;
  }
  if (model_element_family_ == ElementFamily::kThermalShell &&
      (block.canonical_name == "STATIC" ||
       block.canonical_name == "FREQUENCY" ||
       block.canonical_name == "DYNAMIC")) {
    diagnostics_.InputFailure("unsupported-analysis-procedure", block.location,
                              block.canonical_name, step_.name_raw,
                              "DS4 supports only one HEAT TRANSFER procedure.");
    return;
  }
  if (block.canonical_name == "END STEP") {
    active_output_ = false;
    if (!diagnostics_.ValidateParameters(block, {}) ||
        !diagnostics_.RequireNoData(block)) {
      return;
    }
    if (!step_.has_static && !step_.frequency && !step_.dynamic &&
        !step_.has_heat_transfer) {
      diagnostics_.InvalidKeywordLocation(
          block, "The sole step requires one supported procedure keyword.");
      return;
    }
    in_step_ = false;
    return;
  }
  if (block.canonical_name == "STEP") {
    diagnostics_.InputFailure("unsupported-multiple-step", block.location,
                              block.canonical_name, "",
                              "A second or nested step is unsupported.");
    return;
  }
  if (block.canonical_name == "HEAT TRANSFER") {
    active_output_ = false;
    if (step_.has_static || step_.frequency || step_.dynamic ||
        step_.has_heat_transfer || !step_.boundaries.empty() ||
        !step_.loads.empty() || step_no_op_seen_) {
      diagnostics_.InvalidKeywordLocation(
          block, "HEAT TRANSFER must be the first procedure.");
      return;
    }
    ParseHeatTransfer(block);
  } else if (block.canonical_name == "STATIC") {
    active_output_ = false;
    if (!step_.boundaries.empty() || !step_.loads.empty() ||
        !step_.surface_pressure_loads.empty() || step_no_op_seen_) {
      diagnostics_.InvalidKeywordLocation(
          block, "STATIC must be the first keyword in the sole step.");
      return;
    }
    ParseStatic(block);
  } else if (block.canonical_name == "FREQUENCY") {
    active_output_ = false;
    if (step_.has_static || step_.frequency || !step_.boundaries.empty() ||
        !step_.loads.empty() || !step_.surface_pressure_loads.empty() ||
        step_no_op_seen_) {
      diagnostics_.InvalidKeywordLocation(
          block, "FREQUENCY must be the first procedure in the sole step.");
      return;
    }
    ParseFrequency(block);
  } else if (block.canonical_name == "DYNAMIC") {
    active_output_ = false;
    if (step_.has_static || step_.frequency || step_.dynamic ||
        !step_.boundaries.empty() || !step_.loads.empty() ||
        !step_.surface_pressure_loads.empty() || step_no_op_seen_) {
      diagnostics_.InvalidKeywordLocation(
          block, "DYNAMIC must be the first procedure in the sole step.");
      return;
    }
    ParseDynamic(block);
  } else if (block.canonical_name == "BOUNDARY") {
    active_output_ = false;
    if ((!step_.has_static && !step_.frequency && !step_.dynamic &&
         !step_.has_heat_transfer) ||
        step_load_seen_ || step_no_op_seen_) {
      diagnostics_.InvalidKeywordLocation(
          block,
          "Step boundaries follow STATIC and precede loads "
          "and no-op requests.");
      return;
    }
    if (step_.dynamic && !block.parameters.empty()) {
      diagnostics_.InputFailure(
          "unsupported-dynamic-boundary", block.location, block.canonical_name,
          "", "Dynamic BOUNDARY does not support keyword parameters.");
      return;
    }
    if (step_.has_heat_transfer) {
      ParseThermalBoundary(block, step_.thermal_boundaries);
    } else {
      ParseBoundary(block, step_.boundaries);
    }
    if (!diagnostics_.HasFailure() && step_.frequency) {
      ValidateEigenBoundaries(step_.boundaries);
    }
    if (!diagnostics_.HasFailure() && step_.dynamic) {
      ValidateDynamicBoundaries(step_.boundaries);
    }
  } else if (block.canonical_name == "CLOAD") {
    active_output_ = false;
    if ((!step_.has_static && !step_.dynamic) || step_no_op_seen_) {
      diagnostics_.InvalidKeywordLocation(
          block,
          "CLOAD follows STATIC and boundaries and precedes no-op requests.");
      return;
    }
    ParseCload(block, step_.loads);
    if (!diagnostics_.HasFailure()) {
      step_.next_load_ordinal += block.data.size();
    }
    step_load_seen_ = !diagnostics_.HasFailure();
  } else if (block.canonical_name == "CFLUX") {
    active_output_ = false;
    if (!step_.has_heat_transfer || step_no_op_seen_) {
      diagnostics_.InvalidKeywordLocation(
          block, "CFLUX follows HEAT TRANSFER and boundaries.");
      return;
    }
    ParseCflux(block);
    step_load_seen_ = !diagnostics_.HasFailure();
  } else if (block.canonical_name == "DSLOAD") {
    active_output_ = false;
    if (!step_.has_static || step_.dynamic || step_no_op_seen_) {
      diagnostics_.InvalidKeywordLocation(
          block,
          "DSLOAD follows STATIC and boundaries and "
          "precedes no-op requests.");
      return;
    }
    ParseDsload(block);
    step_load_seen_ = !diagnostics_.HasFailure();
  } else if (block.canonical_name == "RESTART") {
    active_output_ = false;
    if (!step_.has_static && !step_.frequency && !step_.dynamic &&
        !step_.has_heat_transfer) {
      diagnostics_.InvalidKeywordLocation(
          block, "Step no-op requests follow STATIC, boundaries, and loads.");
      return;
    }
    step_no_op_seen_ = true;
    if (step_.frequency || step_.has_heat_transfer ||
        model_element_family_ == ElementFamily::kSolid) {
      const auto* write = diagnostics_.Parameter(block, "WRITE");
      const auto* frequency = diagnostics_.Parameter(block, "FREQUENCY");
      if (!diagnostics_.ValidateParameters(block, {"WRITE", "FREQUENCY"}) ||
          write == nullptr || write->value || frequency == nullptr ||
          !frequency->value || *frequency->value != "0") {
        if (!diagnostics_.HasFailure()) {
          diagnostics_.InputFailure(
              "unsupported-keyword", block.location, block.canonical_name, "",
              "Supported RESTART no-op requires WRITE, FREQUENCY=0.");
        }
        return;
      }
    }
    if (diagnostics_.RequireNoData(block)) {
      AddIgnoredWarning(block);
    }
  } else if (block.canonical_name == "OUTPUT") {
    if (!step_.has_static && !step_.frequency && !step_.dynamic &&
        !step_.has_heat_transfer) {
      diagnostics_.InvalidKeywordLocation(
          block, "Step no-op requests follow STATIC, boundaries, and loads.");
      return;
    }
    step_no_op_seen_ = true;
    ParseOutputRoot(block);
  } else if (block.canonical_name == "NODE OUTPUT" ||
             block.canonical_name == "ELEMENT OUTPUT" ||
             block.canonical_name == "CONTACT OUTPUT" ||
             block.canonical_name == "ENERGY OUTPUT") {
    ParseOutputChild(block);
  } else {
    active_output_ = false;
    if (step_.procedure_kind == StaticProcedureKind::kNonlinearFullNewton &&
        !step_.has_static) {
      diagnostics_.InputFailure(
          "unsupported-analysis-procedure", block.location,
          block.canonical_name, "",
          "The nonlinear step supports only the STATIC procedure.");
      return;
    }
    diagnostics_.RejectUnknown(block,
                               model_element_family_ == ElementFamily::kShell);
  }
}

bool StepDefinitionCandidates::ParseFrequencyModeCount(
    const std::string& text, std::int64_t& value,
    const SourceLocation& location) {
  if (text.empty() ||
      !std::all_of(text.begin(), text.end(), [](char character) {
        return character >= '0' && character <= '9';
      })) {
    return diagnostics_.InputFailure(
        "invalid-frequency-data", location, "FREQUENCY", text,
        "The requested mode count must be positive decimal digits.");
  }
  const auto parsed =
      std::from_chars(text.data(), text.data() + text.size(), value);
  if (parsed.ec != std::errc{} || parsed.ptr != text.data() + text.size() ||
      value <= 0) {
    return diagnostics_.InputFailure(
        "invalid-frequency-data", location, "FREQUENCY", text,
        "The requested mode count must be a positive int64 value.");
  }
  return true;
}

void StepDefinitionCandidates::ParseFrequency(const KeywordBlock& block) {
  if (step_.nlgeom || (step_.perturbation_explicit && step_.has_static) ||
      !diagnostics_.ValidateParameters(
          block, {"EIGENSOLVER", "SIM", "ACOUSTIC COUPLING", "NORMALIZATION"},
          "unsupported-frequency-option")) {
    if (!diagnostics_.HasFailure()) {
      diagnostics_.InputFailure(
          "unsupported-analysis-procedure", block.location,
          block.canonical_name, "",
          "FREQUENCY requires the original linear configuration.");
    }
    return;
  }
  if (block.data.size() != 1U || block.data[0].fields.empty() ||
      block.data[0].fields.size() > 7U) {
    diagnostics_.InputFailure(
        "invalid-frequency-data", block.location, block.canonical_name, "",
        "FREQUENCY requires one data row with one to seven fields.");
    return;
  }
  for (std::size_t field = 1U; field < block.data[0].fields.size(); ++field) {
    if (!block.data[0].fields[field].empty()) {
      diagnostics_.InputFailure(
          "invalid-frequency-data", block.data[0].location,
          block.canonical_name, std::to_string(field + 1U),
          "Only the requested mode-count field may be non-empty.");
      return;
    }
  }
  FrequencyStepDefinition frequency{step_.name_raw,
                                    step_.name_canonical,
                                    step_.location,
                                    block.location,
                                    block.data[0].location,
                                    0,
                                    step_.nlgeom_explicit,
                                    step_.perturbation_explicit,
                                    false,
                                    false,
                                    false,
                                    false,
                                    FrequencyEigensolver::kLanczos,
                                    FrequencyNormalization::kMass,
                                    {}};
  if (!ParseFrequencyModeCount(block.data[0].fields[0],
                               frequency.requested_mode_count,
                               block.data[0].location)) {
    return;
  }
  const auto* eigensolver = diagnostics_.Parameter(block, "EIGENSOLVER");
  if (eigensolver != nullptr) {
    if (!eigensolver->value ||
        !AsciiCaseInsensitiveEquals(*eigensolver->value, "LANCZOS")) {
      diagnostics_.InputFailure("unsupported-frequency-option", block.location,
                                block.canonical_name, "EIGENSOLVER",
                                "Only EIGENSOLVER=LANCZOS is accepted.");
      return;
    }
    frequency.eigensolver_explicit = true;
  }
  const auto* sim = diagnostics_.Parameter(block, "SIM");
  if (sim != nullptr) {
    if (sim->value && !AsciiCaseInsensitiveEquals(*sim->value, "YES")) {
      diagnostics_.InputFailure("unsupported-frequency-option", block.location,
                                block.canonical_name, "SIM",
                                "SIM accepts only a flag or YES.");
      return;
    }
    frequency.sim_explicit = true;
  }
  const auto* acoustic = diagnostics_.Parameter(block, "ACOUSTIC COUPLING");
  if (acoustic != nullptr) {
    if (!acoustic->value ||
        !AsciiCaseInsensitiveEquals(*acoustic->value, "ON")) {
      diagnostics_.InputFailure("unsupported-frequency-option", block.location,
                                block.canonical_name, "ACOUSTIC COUPLING",
                                "Only ACOUSTIC COUPLING=ON is accepted.");
      return;
    }
    frequency.acoustic_coupling_explicit = true;
  }
  const auto* normalization = diagnostics_.Parameter(block, "NORMALIZATION");
  if (normalization != nullptr) {
    if (!normalization->value ||
        !AsciiCaseInsensitiveEquals(*normalization->value, "MASS")) {
      diagnostics_.InputFailure("unsupported-frequency-option", block.location,
                                block.canonical_name, "NORMALIZATION",
                                "Only NORMALIZATION=MASS is accepted.");
      return;
    }
    frequency.normalization_explicit = true;
  }
  step_.frequency = std::move(frequency);
  definition_.warnings.push_back(
      {Severity::kWarning, "source-eigensolver-mapped-to-feast", block.location,
       block.canonical_name, step_.name_raw,
       "The accepted source eigensolver is mapped to the FEAST backend."});
  if (step_.frequency->sim_explicit) {
    definition_.warnings.push_back(
        {Severity::kWarning, "source-sim-option-not-applied", block.location,
         block.canonical_name, step_.name_raw,
         "The accepted source SIM option has no FESA runtime effect."});
  }
  if (step_.frequency->acoustic_coupling_explicit) {
    definition_.warnings.push_back(
        {Severity::kWarning, "acoustic-option-inapplicable-structural-only",
         block.location, block.canonical_name, step_.name_raw,
         "Acoustic coupling is inapplicable to this structural-only model."});
  }
}

void StepDefinitionCandidates::ValidateEigenBoundaries(
    const std::vector<PrescribedDisplacementDefinition>& boundaries) {
  for (const auto& boundary : boundaries) {
    if (boundary.value != 0.0) {
      diagnostics_.InputFailure(
          "unsupported-eigen-boundary", boundary.location, "BOUNDARY",
          boundary.target, "Frequency boundaries must prescribe exact zero.");
      return;
    }
  }
}

void StepDefinitionCandidates::ValidateDynamicBoundaries(
    const std::vector<PrescribedDisplacementDefinition>& boundaries) {
  for (const auto& boundary : boundaries) {
    if (boundary.value != 0.0) {
      diagnostics_.InputFailure(
          "unsupported-dynamic-boundary", boundary.location, "BOUNDARY",
          boundary.target,
          "Dynamic boundaries must be homogeneous and constant.");
      return;
    }
  }
}

void StepDefinitionCandidates::ParseDynamic(const KeywordBlock& block) {
  if (step_.perturbation_explicit ||
      (model_element_family_ != ElementFamily::kSolid &&
       (!step_.nlgeom || model_element_family_ != ElementFamily::kShell)) ||
      !diagnostics_.ValidateParameters(block, {"DIRECT"},
                                       "unsupported-dynamic-parameter")) {
    if (!diagnostics_.HasFailure()) {
      diagnostics_.InputFailure(
          "unsupported-analysis-procedure", block.location,
          block.canonical_name, "",
          "DYNAMIC requires nonlinear Shell or linear/nonlinear "
          "Solid geometry.");
    }
    return;
  }
  if (model_element_family_ == ElementFamily::kSolid &&
      block.data.size() == 1U && block.data[0].fields.size() > 3U) {
    diagnostics_.InputFailure(
        "invalid-dynamic-data", block.data[0].location, block.canonical_name,
        "", "Solid DYNAMIC requires h,T with at most one blank field.");
    return;
  }
  const auto* direct = diagnostics_.Parameter(block, "DIRECT");
  if (direct == nullptr || direct->value || block.data.size() != 1U ||
      block.data[0].fields.size() < 2U ||
      std::any_of(block.data[0].fields.begin() + 2, block.data[0].fields.end(),
                  [](const auto& field) { return !field.empty(); })) {
    diagnostics_.InputFailure(
        "invalid-dynamic-data", block.location, block.canonical_name, "",
        "DYNAMIC,DIRECT requires one row with increment and time period.");
    return;
  }
  DynamicStepDefinition dynamic{step_.name_raw,
                                step_.name_canonical,
                                step_.location,
                                block.location,
                                block.data[0].location,
                                0.0,
                                0.0,
                                0U,
                                step_.maximum_increments,
                                -0.05,
                                0.275625,
                                0.55,
                                {},
                                {}};
  if (!ParseDynamicDouble(block.data[0].fields[0], dynamic.initial_increment,
                          block.data[0].location, block.canonical_name) ||
      !ParseDynamicDouble(block.data[0].fields[1], dynamic.time_period,
                          block.data[0].location, block.canonical_name) ||
      !(dynamic.initial_increment > 0.0) || !(dynamic.time_period > 0.0)) {
    if (!diagnostics_.HasFailure()) {
      diagnostics_.InputFailure(
          "invalid-dynamic-data", block.data[0].location, block.canonical_name,
          "", "Dynamic increment and time period must be finite and positive.");
    }
    return;
  }
  const double count = dynamic.time_period / dynamic.initial_increment;
  const double rounded_count = std::round(count);
  if (!std::isfinite(count) || rounded_count < 1.0 ||
      rounded_count >
          static_cast<double>(std::numeric_limits<std::uint32_t>::max()) ||
      dynamic.initial_increment * rounded_count != dynamic.time_period) {
    diagnostics_.InputFailure(
        "invalid-dynamic-schedule", block.data[0].location,
        block.canonical_name, "",
        "DYNAMIC,DIRECT requires an exact positive integer number "
        "of increments.");
    return;
  }
  dynamic.increment_count = static_cast<std::uint32_t>(rounded_count);
  if (dynamic.increment_count > dynamic.maximum_increments) {
    diagnostics_.InputFailure(
        "invalid-dynamic-schedule", block.data[0].location,
        block.canonical_name, "",
        "DYNAMIC,DIRECT increment count cannot exceed STEP INC.");
    return;
  }
  dynamic.nlgeom = step_.nlgeom;
  step_.dynamic = std::move(dynamic);
}

void StepDefinitionCandidates::ParseHeatTransfer(const KeywordBlock& block) {
  if (model_element_family_ != ElementFamily::kThermalShell || step_.nlgeom ||
      step_.perturbation_explicit ||
      !diagnostics_.ValidateParameters(block, {"END"},
                                       "unsupported-thermal-option") ||
      block.data.size() != 1U) {
    if (!diagnostics_.HasFailure())
      diagnostics_.InputFailure(
          "unsupported-analysis-procedure", block.location,
          block.canonical_name, "",
          "HEAT TRANSFER requires the DS4 thermal subset.");
    return;
  }
  const auto* end = diagnostics_.Parameter(block, "END");
  if (end != nullptr &&
      (!end->value || !AsciiCaseInsensitiveEquals(*end->value, "PERIOD"))) {
    diagnostics_.InputFailure("unsupported-thermal-option", block.location,
                              block.canonical_name, "END",
                              "HEAT TRANSFER accepts only END=PERIOD.");
    return;
  }
  if (block.data[0].fields.size() > 5U) {
    diagnostics_.InputFailure(
        "invalid-thermal-time-grid", block.data[0].location,
        block.canonical_name, "",
        "HEAT TRANSFER permits at most three trailing empty fields.");
    return;
  }
  const auto fields = WithoutTrailingEmpty(block.data[0].fields);
  if (fields.size() != 2U) {
    diagnostics_.InputFailure(
        "invalid-thermal-time-grid", block.data[0].location,
        block.canonical_name, "",
        "HEAT TRANSFER requires increment and time period.");
    return;
  }
  if (!diagnostics_.ParseThermalDouble(fields[0], step_.thermal_increment,
                                       block.data[0].location,
                                       block.canonical_name) ||
      !diagnostics_.ParseThermalDouble(fields[1], step_.thermal_period,
                                       block.data[0].location,
                                       block.canonical_name) ||
      !(step_.thermal_increment > 0.0) || !(step_.thermal_period > 0.0)) {
    if (!diagnostics_.HasFailure())
      diagnostics_.InputFailure(
          "invalid-thermal-time-grid", block.data[0].location,
          block.canonical_name, "",
          "Thermal increment and period must be finite and positive.");
    return;
  }
  const auto grid = ThermalTimeGrid::Create(
      step_.thermal_period, step_.thermal_increment, step_.maximum_increments);
  if (!grid.HasValue()) {
    auto diagnostic = grid.GetStatus().Diagnostics().front();
    diagnostic.location = block.data[0].location;
    diagnostic.keyword = block.canonical_name;
    diagnostic.entity_identity = step_.name_raw;
    diagnostics_.Fail(
        grid.GetStatus().Category().value_or(FailureCategory::kInput),
        std::move(diagnostic.code), diagnostic.location,
        std::move(diagnostic.keyword), std::move(diagnostic.entity_identity),
        std::move(diagnostic.message));
    return;
  }
  step_.has_heat_transfer = true;
}

void StepDefinitionCandidates::ParseCflux(const KeywordBlock& block) {
  if (!diagnostics_.ValidateParameters(block, {}) || block.data.empty()) {
    if (!diagnostics_.HasFailure())
      diagnostics_.InputFailure("invalid-data-arity", block.location,
                                block.canonical_name, "",
                                "CFLUX requires target, DOF, power rows.");
    return;
  }
  for (const auto& row : block.data) {
    if (row.fields.size() != 3U || row.fields[0].empty()) {
      diagnostics_.InputFailure("invalid-data-arity", row.location,
                                block.canonical_name, "",
                                "CFLUX rows require target, DOF, power.");
      return;
    }
    std::int64_t dof = 0;
    double power = 0.0;
    if (!diagnostics_.ParseInteger(row.fields[1], dof, row.location,
                                   block.canonical_name, true) ||
        !diagnostics_.ParseThermalDouble(row.fields[2], power, row.location,
                                         block.canonical_name) ||
        (dof != 11 && dof != 15)) {
      diagnostics_.InputFailure("invalid-dof", row.location,
                                block.canonical_name, row.fields[0],
                                "CFLUX supports DOF 11 or 15.");
      return;
    }
    step_.thermal_fluxes.push_back(
        {row.fields[0], static_cast<int>(dof), power, row.location});
  }
}

void StepDefinitionCandidates::ParseStatic(const KeywordBlock& block) {
  if (model_element_family_ == ElementFamily::kSolid &&
      diagnostics_.Parameter(block, "DIRECT")) {
    if (step_.perturbation_explicit || step_.has_static || step_.frequency ||
        step_.dynamic) {
      diagnostics_.InputFailure(
          "unsupported-analysis-procedure", block.location,
          block.canonical_name, step_.name_raw,
          "STATIC DIRECT requires one non-perturbation procedure.");
      return;
    }
    if (!diagnostics_.ValidateParameters(block, {"DIRECT"})) return;
    const auto* direct = diagnostics_.Parameter(block, "DIRECT");
    if (direct->value || block.data.size() != 1U ||
        (block.data[0].fields.size() < 2U || block.data[0].fields.size() > 3U ||
         std::any_of(block.data[0].fields.begin() + 2,
                     block.data[0].fields.end(),
                     [](const auto& field) { return !field.empty(); }))) {
      diagnostics_.InputFailure("invalid-static-data", block.location,
                                block.canonical_name, "DIRECT",
                                "STATIC DIRECT requires exactly h,T.");
      return;
    }
    double h = 0.0;
    double period = 0.0;
    if (!diagnostics_.ParseDouble(block.data[0].fields[0], h,
                                  block.data[0].location, "STATIC") ||
        !diagnostics_.ParseDouble(block.data[0].fields[1], period,
                                  block.data[0].location, "STATIC"))
      return;
    const double count = std::round(period / h);
    if (!(h > 0.0) || !(period > 0.0) || !std::isfinite(count) || count < 1.0 ||
        count > static_cast<double>(step_.maximum_increments) ||
        h * count != period) {
      diagnostics_.InputFailure(
          "invalid-static-schedule", block.data[0].location,
          block.canonical_name, "DIRECT",
          "STATIC DIRECT requires positive exact N*h=T and N<=INC.");
      return;
    }
    step_.static_values = {h, period, h, h};
    step_.static_direct = true;
    step_.static_increment_count = static_cast<std::uint32_t>(count);
    step_.has_static = true;
    return;
  }
  if (step_.perturbation_explicit || step_.frequency) {
    diagnostics_.InputFailure("unsupported-analysis-procedure", block.location,
                              block.canonical_name, "PERTURBATION",
                              "PERTURBATION is supported only with FREQUENCY.");
    return;
  }
  if (step_.has_heat_transfer || step_.has_static ||
      !diagnostics_.ValidateParameters(block, {}) || block.data.size() != 1U ||
      block.data[0].fields.size() != 4U) {
    if (!diagnostics_.HasFailure()) {
      diagnostics_.InputFailure(
          step_.nlgeom ? "invalid-nonlinear-static-data"
                       : "invalid-static-data",
          block.location, block.canonical_name, "",
          "STATIC requires exactly one row of four values.");
    }
    return;
  }
  for (std::size_t field = 0U; field < 4U; ++field) {
    const std::string& text = block.data[0].fields[field];
    const bool parsed = step_.nlgeom
                            ? ParseNonlinearStaticDouble(
                                  text, step_.static_values[field],
                                  block.data[0].location, block.canonical_name)
                            : diagnostics_.ParseDouble(
                                  text, step_.static_values[field],
                                  block.data[0].location, block.canonical_name);
    if (!parsed) {
      return;
    }
    if (step_.static_values[field] <= 0.0) {
      diagnostics_.InputFailure(step_.nlgeom ? "invalid-nonlinear-static-data"
                                             : "invalid-static-data",
                                block.data[0].location, block.canonical_name,
                                "", "All four STATIC fields must be positive.");
      return;
    }
  }
  if (step_.static_values[2] > step_.static_values[3]) {
    diagnostics_.InputFailure(
        step_.nlgeom ? "invalid-nonlinear-static-data" : "invalid-static-data",
        block.data[0].location, block.canonical_name, "",
        "STATIC minimum increment cannot exceed maximum increment.");
    return;
  }
  if (step_.nlgeom && step_.static_values[1] != 1.0) {
    diagnostics_.InputFailure(
        "invalid-nonlinear-static-data", block.data[0].location,
        block.canonical_name, "",
        "The nonlinear STATIC time period must be exactly 1.0.");
    return;
  }
  step_.has_static = true;
}

void StepDefinitionCandidates::ParseOutputRoot(const KeywordBlock& block) {
  if (step_.has_heat_transfer) {
    const auto* field = diagnostics_.Parameter(block, "FIELD");
    const auto* history = diagnostics_.Parameter(block, "HISTORY");
    const auto* variable = diagnostics_.Parameter(block, "VARIABLE");
    const auto* frequency = diagnostics_.Parameter(block, "FREQUENCY");
    const bool valid_field =
        field && !field->value && variable && variable->value &&
        AsciiCaseInsensitiveEquals(*variable->value, "PRESELECT");
    const bool valid_history = history && !history->value && frequency &&
                               frequency->value && *frequency->value == "0";
    if (!diagnostics_.RequireNoData(block)) return;
    if (block.parameters.size() != 2U || (!valid_field && !valid_history)) {
      diagnostics_.InputFailure(
          "unsupported-keyword", block.location, block.canonical_name, "",
          "Thermal OUTPUT accepts FIELD, VARIABLE=PRESELECT or "
          "HISTORY, FREQUENCY=0.");
      return;
    }
    AddIgnoredWarning(block);
    return;
  }
  if (!diagnostics_.ValidateParameters(
          block, (step_.dynamic || step_.has_heat_transfer)
                     ? std::vector<std::string_view>{"FIELD", "HISTORY",
                                                     "VARIABLE", "FREQUENCY"}
                     : std::vector<std::string_view>{"FIELD", "HISTORY",
                                                     "VARIABLE"})) {
    return;
  }
  const auto* field = diagnostics_.Parameter(block, "FIELD");
  const auto* history = diagnostics_.Parameter(block, "HISTORY");
  const auto* variable = diagnostics_.Parameter(block, "VARIABLE");
  if ((field == nullptr) == (history == nullptr) ||
      (field != nullptr && field->value) ||
      (history != nullptr && history->value)) {
    diagnostics_.InputFailure(
        step_.nlgeom ? "invalid-keyword-parameter" : "unsupported-keyword",
        block.location, block.canonical_name, "",
        "OUTPUT must select exactly FIELD or HISTORY.");
    return;
  }
  if (model_element_family_ == ElementFamily::kSolid &&
      ((variable && (!variable->value || !AsciiCaseInsensitiveEquals(
                                             *variable->value, "PRESELECT"))) ||
       !diagnostics_.RequireNoData(block))) {
    if (!diagnostics_.HasFailure())
      diagnostics_.InputFailure(
          "unsupported-keyword", block.location, block.canonical_name,
          "VARIABLE", "Solid OUTPUT accepts only PRESELECT requests.");
    return;
  }
  if (step_.nlgeom &&
      (variable == nullptr || !variable->value ||
       !AsciiCaseInsensitiveEquals(*variable->value, "PRESELECT"))) {
    diagnostics_.InputFailure("invalid-keyword-parameter", block.location,
                              block.canonical_name, "VARIABLE",
                              "Nonlinear OUTPUT requires VARIABLE=PRESELECT.");
    return;
  }
  if (step_.dynamic) {
    const auto* frequency = diagnostics_.Parameter(block, "FREQUENCY");
    if (!diagnostics_.ValidateParameters(
            block, {"FIELD", "HISTORY", "VARIABLE", "FREQUENCY"}) ||
        variable == nullptr || !variable->value ||
        !AsciiCaseInsensitiveEquals(*variable->value, "PRESELECT") ||
        (frequency != nullptr &&
         (!frequency->value || *frequency->value != "1")) ||
        !diagnostics_.RequireNoData(block)) {
      if (!diagnostics_.HasFailure()) {
        diagnostics_.InputFailure(
            "unsupported-keyword", block.location, block.canonical_name, "",
            "Dynamic OUTPUT accepts only VARIABLE=PRESELECT, FREQUENCY=1.");
      }
      return;
    }
  } else if (step_.frequency &&
             ((variable != nullptr &&
               (!variable->value ||
                !AsciiCaseInsensitiveEquals(*variable->value, "PRESELECT"))) ||
              !diagnostics_.RequireNoData(block))) {
    if (!diagnostics_.HasFailure()) {
      diagnostics_.InputFailure(
          "unsupported-keyword", block.location, block.canonical_name, "",
          "Frequency OUTPUT accepts only VARIABLE=PRESELECT.");
    }
    return;
  }
  active_output_ = true;
  active_output_is_field_ = field != nullptr;
  AddIgnoredWarning(block);
}

void StepDefinitionCandidates::ParseOutputChild(const KeywordBlock& block) {
  if (step_.has_heat_transfer) {
    diagnostics_.InputFailure(
        "unsupported-keyword", block.location, block.canonical_name, "",
        "Thermal output children are outside the approved subset.");
    return;
  }
  if (!active_output_) {
    diagnostics_.InputFailure(
        "invalid-keyword-location", block.location, block.canonical_name, "",
        "Output variable keywords require an active OUTPUT request.");
    return;
  }
  if (model_element_family_ == ElementFamily::kSolid && step_.dynamic) {
    diagnostics_.InputFailure(
        "unsupported-keyword", block.location, block.canonical_name, "",
        "Solid dynamic output children are outside the approved subset.");
    return;
  }
  if (model_element_family_ == ElementFamily::kSolid && step_.has_static) {
    const auto* variable = diagnostics_.Parameter(block, "VARIABLE");
    const auto* directions = diagnostics_.Parameter(block, "DIRECTIONS");
    const bool node = block.canonical_name == "NODE OUTPUT";
    const bool element = block.canonical_name == "ELEMENT OUTPUT";
    const bool contact = block.canonical_name == "CONTACT OUTPUT";
    if (!active_output_is_field_ || (!node && !element && !contact) ||
        !diagnostics_.ValidateParameters(
            block, element
                       ? std::vector<std::string_view>{"VARIABLE", "DIRECTIONS"}
                       : std::vector<std::string_view>{"VARIABLE"}) ||
        (directions &&
         (!directions->value ||
          !AsciiCaseInsensitiveEquals(*directions->value, "YES"))) ||
        (variable &&
         (!variable->value ||
          !AsciiCaseInsensitiveEquals(*variable->value, "PRESELECT"))) ||
        (contact && (!variable || !block.data.empty()))) {
      if (!diagnostics_.HasFailure())
        diagnostics_.InputFailure("unsupported-keyword", block.location,
                                  block.canonical_name, "",
                                  "Solid static output child is unsupported.");
      return;
    }
    for (const auto& row : block.data) {
      for (const auto& field : row.fields) {
        const std::string token = AsciiUppercase(field);
        if (!(node ? (token == "U" || token == "RF")
                   : (token == "S" || token == "E"))) {
          diagnostics_.InputFailure(
              "unsupported-keyword", row.location, block.canonical_name, field,
              "Solid output quantities must be physical supported "
              "components.");
          return;
        }
      }
    }
  }
  if (step_.frequency) {
    const std::string_view required_variable =
        block.canonical_name == "NODE OUTPUT" ? "PRESELECT" : "ALL";
    const auto* variable = diagnostics_.Parameter(block, "VARIABLE");
    if ((block.canonical_name != "NODE OUTPUT" &&
         block.canonical_name != "ENERGY OUTPUT") ||
        (block.canonical_name == "NODE OUTPUT" && !active_output_is_field_) ||
        (block.canonical_name == "ENERGY OUTPUT" && active_output_is_field_) ||
        !diagnostics_.ValidateParameters(block, {"VARIABLE"}) ||
        variable == nullptr || !variable->value ||
        !AsciiCaseInsensitiveEquals(*variable->value, required_variable) ||
        !diagnostics_.RequireNoData(block)) {
      if (!diagnostics_.HasFailure()) {
        diagnostics_.InputFailure(
            "unsupported-keyword", block.location, block.canonical_name, "",
            "Frequency output child is outside the approved subset.");
      }
      return;
    }
  }
  AddIgnoredWarning(block);
}

void StepDefinitionCandidates::AddIgnoredWarning(const KeywordBlock& block) {
  // One warning per allowlisted keyword keeps no-op provenance stable;
  // subordinate variable rows remain attached to that keyword record.
  definition_.warnings.push_back(
      {Severity::kWarning,
       step_.dynamic ? "ignored-output-request" : "ignored-input-keyword",
       block.location, block.canonical_name, "",
       "The allowlisted Abaqus keyword is "
       "ignored without semantic effect."});
}

std::optional<std::vector<EntityIndex>>
StepDefinitionCandidates::ResolveNodeTarget(
    const SourceTargetResolver& resolver, const std::string& target,
    const SourceLocation& location, const std::string& keyword) {
  auto resolved = resolver.Resolve({SourceEntityKind::kNode, "", target});
  if (!resolved.HasValue()) {
    diagnostics_.InputFailure(
        "unresolved-reference", location, keyword, target,
        "The boundary or load target must resolve unambiguously to one "
        "node or one node set.");
    return std::nullopt;
  }
  std::vector<EntityIndex> indices;
  indices.reserve(resolved.Value().size());
  for (const auto& entry : resolved.Value()) {
    if (model_element_family_ == ElementFamily::kThermalShell &&
        !thermal_active_nodes_[entry.entity_index]) {
      diagnostics_.ModelFailure(
          "inactive-thermal-target", location, keyword, target,
          "Thermal targets must connect to an active DS4 element.");
      return std::nullopt;
    }
    indices.push_back(entry.entity_index);
  }
  return indices;
}

void StepDefinitionCandidates::FinalizeStep() {
  if (step_.has_heat_transfer) {
    thermal_active_nodes_.assign(definition_.nodes.size(), false);
    for (const auto& element : definition_.thermal_elements)
      for (const auto node : element.node_indices)
        thermal_active_nodes_[node] = true;
    const SourceTargetIndex target_index = SourceTargetIndex::FromNodeDefinitions(definition_.nodes, definition_.node_sets);
    const SourceTargetResolver resolver{target_index};
    const auto append_boundaries =
        [this, &resolver](
            const std::vector<RawThermalBoundary>& rows,
            std::map<std::pair<EntityIndex, int>, double>* values,
            std::vector<ThermalBoundaryConditionDefinition>* out) {
          for (const auto& row : rows) {
            const auto nodes = ResolveNodeTarget(resolver, row.target,
                                                 row.location, "BOUNDARY");
            if (!nodes) return false;
            for (const EntityIndex node : *nodes) {
              const auto key = std::make_pair(node, row.dof);
              const auto existing = values->find(key);
              if (existing != values->end() && existing->second != row.value) {
                return diagnostics_.InputFailure(
                    "conflicting-boundary-condition", row.location, "BOUNDARY",
                    row.target,
                    "Expanded thermal boundaries prescribe "
                    "different values.");
              }
              (*values)[key] = row.value;
              out->push_back({node, row.dof, row.value, row.location});
            }
          }
          return true;
        };
    std::map<std::pair<EntityIndex, int>, double> model_values;
    if (!append_boundaries(thermal_model_boundaries_, &model_values,
                           &definition_.thermal_model_boundaries))
      return;
    std::vector<ThermalBoundaryConditionDefinition> step_boundaries;
    std::map<std::pair<EntityIndex, int>, double> step_values;
    if (!append_boundaries(step_.thermal_boundaries, &step_values,
                           &step_boundaries))
      return;
    std::map<EntityIndex, double> initial_values;
    for (const auto& row : thermal_initial_conditions_) {
      const auto nodes = ResolveNodeTarget(resolver, row.target, row.location,
                                           "INITIAL CONDITIONS");
      if (!nodes) return;
      for (const EntityIndex node : *nodes) {
        const auto inserted = initial_values.emplace(node, row.value);
        if (!inserted.second && inserted.first->second != row.value) {
          diagnostics_.InputFailure(
              "conflicting-initial-temperature", row.location,
              "INITIAL CONDITIONS", row.target,
              "Expanded initial temperatures prescribe different values.");
          return;
        }
        definition_.thermal_initial_conditions.push_back(
            {node, row.value, row.location});
      }
    }
    std::vector<ThermalFluxLoadDefinition> loads;
    for (const auto& row : step_.thermal_fluxes) {
      const auto nodes =
          ResolveNodeTarget(resolver, row.target, row.location, "CFLUX");
      if (!nodes) return;
      for (const EntityIndex node : *nodes) {
        loads.push_back({node, row.dof, row.power, row.location, loads.size()});
      }
    }
    definition_.thermal_step = {step_.name_raw,
                                step_.thermal_increment,
                                step_.thermal_period,
                                step_.maximum_increments,
                                false,
                                std::move(step_boundaries),
                                std::move(loads),
                                step_.location};
    return;
  }
  std::vector<PrescribedDisplacementDefinition> boundaries = model_boundaries_;
  boundaries.insert(boundaries.end(), step_.boundaries.begin(),
                    step_.boundaries.end());
  if (step_.frequency) {
    ValidateEigenBoundaries(boundaries);
    if (diagnostics_.HasFailure()) {
      return;
    }
  }
  if (step_.dynamic) {
    ValidateDynamicBoundaries(boundaries);
    if (diagnostics_.HasFailure()) {
      return;
    }
  }
  const SourceTargetIndex target_index = SourceTargetIndex::FromNodeDefinitions(definition_.nodes, definition_.node_sets);
  const SourceTargetResolver target_resolver{target_index};

  if (model_element_family_ == ElementFamily::kSolid) {
    std::vector<PrescribedDisplacementDefinition> physical;
    for (auto boundary : boundaries) {
      if (!ResolveNodeTarget(target_resolver, boundary.target,
                             boundary.location, "BOUNDARY"))
        return;
      if (boundary.last_dof > 3) {
        if (boundary.value != 0.0) {
          diagnostics_.InputFailure(
              "unsupported-solid-rotation-boundary", boundary.location,
              "BOUNDARY", boundary.target,
              "Solid rotational boundaries must be exact zero to be "
              "inactive.");
          return;
        }
        definition_.warnings.push_back(
            {Severity::kWarning, "inactive-solid-rotation-boundary",
             boundary.location, "BOUNDARY", boundary.target,
             "Exact-zero rotational boundary DOFs " +
                 std::to_string(std::max(4, boundary.first_dof)) + ".." +
                 std::to_string(boundary.last_dof) +
                 " are inactive; Solid equations contain translations "
                 "only."});
        boundary.last_dof = 3;
      }
      if (boundary.first_dof <= boundary.last_dof)
        physical.push_back(std::move(boundary));
    }
    boundaries = std::move(physical);
    std::vector<bool> active(definition_.nodes.size(), false);
    for (const auto& element : definition_.solid_elements)
      for (const auto node : element.node_indices) active[node] = true;
    for (std::size_t node = 0U; node < active.size(); ++node) {
      if (!active[node]) {
        diagnostics_.ModelFailure(
            "unused-solid-node", definition_.nodes[node].location, "NODE",
            definition_.nodes[node].source_id.source_label_text,
            "Every Solid node must connect to a C3D8 element.");
        return;
      }
    }
  }
  std::map<std::pair<EntityIndex, int>, double> prescribed_values;
  for (const auto& boundary : boundaries) {
    auto target = ResolveNodeTarget(target_resolver, boundary.target,
                                    boundary.location, "BOUNDARY");
    if (!target) {
      return;
    }
    for (const auto node : *target) {
      for (int dof = boundary.first_dof; dof <= boundary.last_dof; ++dof) {
        const auto key = std::make_pair(node, dof);
        const auto existing = prescribed_values.find(key);
        if (existing != prescribed_values.end() &&
            existing->second != boundary.value) {
          diagnostics_.InputFailure(
              "conflicting-boundary-condition", boundary.location, "BOUNDARY",
              boundary.target,
              "Expanded boundary rows prescribe different values to "
              "one node/DOF.");
          return;
        }
        prescribed_values[key] = boundary.value;
      }
    }
  }
  for (const auto& load : step_.loads) {
    if (!ResolveNodeTarget(target_resolver, load.target, load.location,
                           "CLOAD")) {
      return;
    }
  }
  if (step_.frequency) {
    step_.frequency->boundaries = std::move(boundaries);
    definition_.frequency_step = std::move(step_.frequency);
    return;
  }
  if (step_.dynamic) {
    step_.dynamic->boundaries = std::move(boundaries);
    step_.dynamic->loads = step_.loads;
    definition_.dynamic_step = std::move(step_.dynamic);
    return;
  }
  std::vector<SurfacePressureLoadDefinition> surface_pressure_loads;
  surface_pressure_loads.reserve(step_.surface_pressure_loads.size());
  for (const auto& load : step_.surface_pressure_loads) {
    const auto surface = std::find_if(
        definition_.element_surfaces.begin(),
        definition_.element_surfaces.end(), [&load](const auto& candidate) {
          return AsciiCaseInsensitiveEquals(candidate.surface_name_raw,
                                            load.surface_name);
        });
    if (surface == definition_.element_surfaces.end()) {
      diagnostics_.InputFailure(
          "missing-reference", load.data_location, "DSLOAD", load.surface_name,
          "A DSLOAD surface must resolve after surface validation.");
      return;
    }
    surface_pressure_loads.push_back(
        {step_.name_raw, step_.name_canonical,
         static_cast<EntityIndex>(
             std::distance(definition_.element_surfaces.begin(), surface)),
         load.surface_name, AsciiUppercase(load.surface_name), "P",
         load.magnitude, load.magnitude_raw, load.keyword_location,
         load.data_location, load.data_ordinal, load.load_ordinal});
  }

  // Static time-control values are provenance only: V0 creates exactly
  // the canonical final frame 0 and performs no increment loop here.
  definition_.steps.push_back(
      {model_element_family_ == ElementFamily::kSolid ? step_.name_raw
                                                      : "Step-1",
       std::move(boundaries), step_.loads, std::move(surface_pressure_loads),
       step_.procedure_kind, step_.nlgeom, step_.static_values[0],
       step_.static_values[1], step_.static_values[2], step_.static_values[3],
       step_.location});
  definition_.steps.back().direct = step_.static_direct;
  definition_.steps.back().increment_count = step_.static_increment_count;
  definition_.steps.back().maximum_increments = step_.maximum_increments;
}

Status StepDefinitionMapper::Map(DomainMappingContext& context) const {
  return context.FinalizeStep();
}

}  // namespace fesa::abaqus_internal