#pragma once

#include <iostream>

#include "autoopt/optimization_problem.hpp"

namespace autoopt {

template <typename T>
struct btls_parameters {
  T step_decrease = T{0.5};
  T step_increase = T{1.5};
  T sufficient_decrease = T{1e-2};
  T tolerance = T{1e-9};
  size_t max_iters = 1000;
};

template <typename T>
void btls(optimization_problem<T>& problem,
          const btls_parameters<T>& params = btls_parameters<T>()) {
  Eigen::VectorX<T>& x = problem.x();
  T step_size = T{1.0};

  for (size_t iter = 0; iter < params.max_iters; ++iter) {
    T obj_value = problem.objective(x);

    std::cout << "Iter " << iter << ": obj = " << obj_value
              << ", x = " << x.transpose() << ", step_size = " << step_size
              << std::endl;

    Eigen::VectorX<T> grad = -problem.gradient(x);

    Eigen::VectorX<T> step_dir = grad.normalized();
    while (problem.objective(x + step_size * step_dir) >
           obj_value +
               params.sufficient_decrease * step_size * grad.dot(step_dir)) {
      step_size *= params.step_decrease;
    }
    x += step_size * step_dir;

    if (step_size < params.tolerance) {
      break;
    }
  }

  problem.x() = x;
}

}  // namespace autoopt