#include "fesa/results/prepared_results_writer.h"

#include "fesa/results/dynamic_results_writer.h"
#include "fesa/results/eigen_results_writer.h"
#include "fesa/results/nonlinear_results_writer.h"
#include "fesa/results/results_writer.h"
#include "fesa/results/solid_results_writer.h"
#include "fesa/results/thermal_results_writer.h"

namespace fesa {

Status WritePreparedAnalysisResult(
    const std::filesystem::path& results_path, const Domain& domain,
    const PreparedAnalysisOutcome& outcome,
    const std::vector<Diagnostic>& diagnostics, ResultsWriter& linear_writer,
    NonlinearResultsWriter& nonlinear_writer, EigenResultsWriter& eigen_writer,
    DynamicResultsWriter* dynamic_writer, ThermalResultsWriter* thermal_writer,
    SolidResultsWriter* solid_writer) {
  if (std::holds_alternative<SolidStaticExecutionResult>(outcome) ||
      std::holds_alternative<SolidFrequencyState>(outcome) ||
      std::holds_alternative<SolidDynamicExecutionResult>(outcome)) {
    if (solid_writer == nullptr)
      return Status::Failure(FailureCategory::kOutput,
                             {{Severity::kError,
                               "missing-solid-writer",
                               {},
                               "",
                               {},
                               "Solid result writer is required."}});
    if (const auto* result = std::get_if<SolidStaticExecutionResult>(&outcome))
      return solid_writer->Write(results_path, domain, result->state,
                                 diagnostics);
    if (const auto* result = std::get_if<SolidFrequencyState>(&outcome))
      return solid_writer->Write(results_path, domain, *result,
                                 diagnostics);
    return solid_writer->Write(
        results_path, domain,
        std::get<SolidDynamicExecutionResult>(outcome).state, diagnostics);
  }
  if (std::holds_alternative<ThermalExecutionResult>(outcome)) {
    if (thermal_writer == nullptr) {
      return Status::Failure(FailureCategory::kOutput,
                             {{Severity::kError,
                               "missing-thermal-writer",
                               {},
                               "HEAT TRANSFER",
                               {},
                               "Thermal result writer is required."}});
    }
    return thermal_writer->Write(
        results_path, domain,
        std::get<ThermalExecutionResult>(outcome).state, diagnostics);
  }
  if (std::holds_alternative<DynamicExecutionResult>(outcome)) {
    if (dynamic_writer == nullptr)
      return Status::Failure(FailureCategory::kOutput,
                             {{Severity::kError,
                               "missing-dynamic-writer",
                               {},
                               "DYNAMIC",
                               {},
                               "Dynamic result writer is required."}});
    return dynamic_writer->Write(
        results_path, domain,
        std::get<DynamicExecutionResult>(outcome).state, diagnostics);
  }
  if (std::holds_alternative<EigenAnalysisState>(outcome)) {
    return eigen_writer.Write(results_path, domain,
                              std::get<EigenAnalysisState>(outcome),
                              diagnostics);
  }
  if (std::holds_alternative<LinearStaticExecutionResult>(outcome)) {
    return linear_writer.Write(
        results_path, domain,
        std::get<LinearStaticExecutionResult>(outcome).state, diagnostics);
  }

  return nonlinear_writer.Write(
      results_path, domain,
      std::get<NonlinearStaticExecutionResult>(outcome).state, diagnostics);
}

}  // namespace fesa