#include "fesa/analysis/transient_heat_procedure.h"

#include <utility>
#include "fesa/assembly/thermal_assembler.h"

#include "thermal_transient_algebra.h"

namespace fesa {

TransientHeatProcedureExecutor::TransientHeatProcedureExecutor(
    const ParallelFor& parallel_for, LinearSolver& linear_solver)
    : parallel_for_{parallel_for}, linear_solver_{linear_solver} {}

Result<ThermalExecutionResult> TransientHeatProcedureExecutor::Execute(
    const Domain& domain) const {
  auto model = AnalysisModel::Create(domain);
  if (!model.HasValue())
    return Result<ThermalExecutionResult>::Failure(model.GetStatus());
  auto dofs = DofManager::CreateThermal(model.Value());
  if (!dofs.HasValue())
    return Result<ThermalExecutionResult>::Failure(dofs.GetStatus());
  auto assembly = AssembleThermal(model.Value(), dofs.Value(), parallel_for_);
  if (!assembly.HasValue())
    return Result<ThermalExecutionResult>::Failure(assembly.GetStatus());
  auto state = ThermalAnalysisState::Create(model.Value(), dofs.Value(),
                                            assembly.Value());
  if (!state.HasValue())
    return Result<ThermalExecutionResult>::Failure(state.GetStatus());
  const Status completed = thermal_transient_internal::RunThermalHistory(
      assembly.Value(), dofs.Value(), state.Value(), linear_solver_,
      [&](const Vector& temperature) {
        return assembly.Value().RecoverFlux(temperature, parallel_for_);
      });
  if (!completed.IsOk())
    return Result<ThermalExecutionResult>::Failure(completed);
  return Result<ThermalExecutionResult>::Success(
      {std::move(state.Value()), domain.Warnings()});
}

}  // namespace fesa