#ifndef FESA_SOLVERS_EIGEN_MKL_FEAST_EIGEN_SOLVER_H_
#define FESA_SOLVERS_EIGEN_MKL_FEAST_EIGEN_SOLVER_H_

#include <cstddef>
#include <cstdint>
#include <string>
#include <vector>

#include "fesa/core/status.h"
#include "fesa/math/matrix.h"

namespace fesa {

class SparseMatrix;

/// @brief Records one deterministic private-backend invocation.
struct FeastBackendCall {
  std::size_t ordinal;
  std::string kind;
  std::string purpose;
  double lower;
  double upper;
  std::size_t allocated_m0;
  int info;
  bool count_available;
  std::size_t count;
  bool loop_available;
  int loop;
  bool epsout_available;
  double epsout;
  std::string outcome;
  std::string decision_reason;
};

/// @brief Owns the complete validated FEAST interval result before public N
/// selection.
struct FeastEigenResult {
  std::size_t requested_modes;
  std::vector<double> eigenvalues;
  Matrix eigenvectors;
  double operator_scale;
  std::vector<std::size_t> column_ids;
  std::vector<bool> backend_res_available;
  std::vector<double> backend_res;
  std::vector<double> normalized_eigenvalues;
  std::vector<double> whitened_residuals;
  double gram_error;
  std::vector<FeastBackendCall> backend_calls;
  std::vector<std::int64_t> base_fpm;
  std::string runtime_version;
  std::string integer_abi;
  std::size_t thread_count;
  std::uint64_t seed;
  double enclosure_lower;
  double enclosure_upper;
  double solve_lower;
  double solve_upper;
  std::string upper_search_termination;
};

/// @brief Solves a whitened real-symmetric eigenproblem with oneMKL FEAST.
class MklFeastEigenSolver final {
 public:
  /// @brief Computes all validated interval pairs for a requested lowest-mode
  /// prefix.
  /// @param whitened_operator Symmetric physical-lambda operator after
  /// whitening.
  /// @param requested_modes Number of lowest modes eventually exposed by the
  /// caller.
  /// @param zero_operator_scale Positive physical scale used only when A is
  /// exactly zero.
  /// @return Sorted all-c eigenpairs in physical lambda units or a solver
  /// failure.
  /// @note The implementation fixes oneMKL local thread count to one during
  /// every call.
  Result<FeastEigenResult> Solve(const SparseMatrix& whitened_operator,
                                 std::size_t requested_modes,
                                 double zero_operator_scale) const;
};

}  // namespace fesa

#endif  // FESA_SOLVERS_EIGEN_MKL_FEAST_EIGEN_SOLVER_H_