#ifndef FESA_ANALYSIS_PREPARED_ANALYSIS_H_
#define FESA_ANALYSIS_PREPARED_ANALYSIS_H_

#include <filesystem>
#include <variant>
#include <vector>

#include "fesa/analysis/analysis_state.h"
#include "fesa/analysis/dynamic_analysis_state.h"
#include "fesa/analysis/eigen_analysis_state.h"
#include "fesa/analysis/nonlinear_analysis_state.h"
#include "fesa/analysis/solid_frequency_state.h"
#include "fesa/analysis/solid_hht_dynamic_procedure.h"
#include "fesa/analysis/solid_static_procedure.h"
#include "fesa/analysis/transient_heat_procedure.h"
#include "fesa/core/diagnostic.h"
#include "fesa/core/status.h"
#include "fesa/model/domain.h"

namespace fesa {

class LinearStaticProcedureExecutor;
class LinearFrequencyProcedureExecutor;
class EigenResultsWriter;
class NewtonIterationLogWriter;
class NonlinearResultsWriter;
class NonlinearStaticProcedureExecutor;
class ResultsWriter;
class HhtDynamicProcedureExecutor;
class DynamicResultsWriter;
class ThermalResultsWriter;
class SolidResultsWriter;
class SolidFrequencyProcedureExecutor;
struct DerivedOutputPaths;

/// @brief Owns one parsed and semantically mapped analysis input.
struct PreparedAnalysisInput {
  Domain domain;
  std::vector<Diagnostic> diagnostics;
};

/// @brief Parses and maps an input file exactly once for procedure execution.
/// @param input_path Source Abaqus input path.
/// @return A movable Domain and sorted mapping diagnostics, or an input
/// failure.
Result<PreparedAnalysisInput> PrepareAnalysisInput(
    const std::filesystem::path& input_path);

/// @brief Stores a completed linear-static calculation before result writing.
struct LinearStaticExecutionResult {
  AnalysisState state;
  std::vector<Diagnostic> diagnostics;
};

/// @brief Stores a completed nonlinear-static calculation before result
/// writing.
struct NonlinearStaticExecutionResult {
  NonlinearAnalysisState state;
  std::vector<Diagnostic> diagnostics;
};

/// @brief Stores a complete HHT history before atomic result finalization.
struct DynamicExecutionResult {
  DynamicAnalysisState state;
  std::vector<Diagnostic> diagnostics;
};

using PreparedAnalysisOutcome =
    std::variant<LinearStaticExecutionResult, NonlinearStaticExecutionResult,
                 EigenAnalysisState, DynamicExecutionResult,
                 ThermalExecutionResult, SolidStaticExecutionResult,
                 SolidFrequencyState, SolidDynamicExecutionResult>;

/// @brief Selects the approved procedure from a prepared Domain.
/// @pre The executors and log outlive this call.
/// @param thermal_executor Required only for a thermal Domain, whose structural
/// step collection is empty; absence returns a solver failure.
/// @return A validated procedure outcome without opening a result file.
Result<PreparedAnalysisOutcome> ExecutePreparedAnalysis(
    const Domain& domain, LinearStaticProcedureExecutor& linear_executor,
    NonlinearStaticProcedureExecutor& nonlinear_executor,
    const LinearFrequencyProcedureExecutor& frequency_executor,
    NewtonIterationLogWriter& log,
    const HhtDynamicProcedureExecutor* dynamic_executor = nullptr,
    const TransientHeatProcedureExecutor* thermal_executor = nullptr,
    const SolidStaticProcedureExecutor* solid_static_executor = nullptr,
    const SolidFrequencyProcedureExecutor* solid_frequency_executor = nullptr,
    const SolidHhtDynamicProcedureExecutor* solid_dynamic_executor = nullptr);

/// @brief Writes an already computed outcome to its authoritative result file.
/// @pre The Newton log has closed successfully before this function is called.
/// @param thermal_writer Required only for a thermal outcome; absence returns
/// an output failure without opening the final result.
/// @return Success after the selected writer atomically finalizes its result.
Status FinalizePreparedAnalysisResult(
    const DerivedOutputPaths& paths, const Domain& domain,
    const PreparedAnalysisOutcome& outcome,
    const std::vector<Diagnostic>& diagnostics, ResultsWriter& linear_writer,
    NonlinearResultsWriter& nonlinear_writer, EigenResultsWriter& eigen_writer,
    DynamicResultsWriter* dynamic_writer = nullptr,
    ThermalResultsWriter* thermal_writer = nullptr,
    SolidResultsWriter* solid_writer = nullptr);

}  // namespace fesa

#endif  // FESA_ANALYSIS_PREPARED_ANALYSIS_H_