// SPDX-License-Identifier: Apache-2.0
//
// Copyright 2008-2016 Conrad Sanderson (http://conradsanderson.id.au)
// Copyright 2008-2016 National ICT Australia (NICTA)
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ------------------------------------------------------------------------

namespace newarp {

// When comparing eigenvalues, we first calculate the "target" to sort.
// For example, if we want to choose the eigenvalues with largest magnitude, the target
// will be -std::abs(x). The minus sign is due to the fact that std::sort() sorts in
// ascending order.

// default target: throw an exception
template <typename eT, int SelectionRule>
struct SortingTarget {
  arma_inline static typename get_pod_type<eT>::result get(const eT& val) {
    arma_ignore(val);
    arma_stop_logic_error("newarp::SortingTarget: incompatible selection rule");

    typedef typename get_pod_type<eT>::result out_T;
    return out_T(0);
  }
};

// specialisation for LARGEST_MAGN: this covers [float, double, complex] x [LARGEST_MAGN]
template <typename eT>
struct SortingTarget<eT, EigsSelect::LARGEST_MAGN> {
  arma_inline static typename get_pod_type<eT>::result get(const eT& val) {
    return -std::abs(val);
  }
};

// specialisation for LARGEST_REAL: this covers [complex] x [LARGEST_REAL]
template <typename T>
struct SortingTarget<std::complex<T>, EigsSelect::LARGEST_REAL> {
  arma_inline static T get(const std::complex<T>& val) { return -val.real(); }
};

// specialisation for LARGEST_IMAG: this covers [complex] x [LARGEST_IMAG]
template <typename T>
struct SortingTarget<std::complex<T>, EigsSelect::LARGEST_IMAG> {
  arma_inline static T get(const std::complex<T>& val) { return -std::abs(val.imag()); }
};

// specialisation for LARGEST_ALGE: this covers [float, double] x [LARGEST_ALGE]
template <typename eT>
struct SortingTarget<eT, EigsSelect::LARGEST_ALGE> {
  arma_inline static eT get(const eT& val) { return -val; }
};

// Here BOTH_ENDS is the same as LARGEST_ALGE, but we need some additional steps,
// which are done in SymEigsSolver => retrieve_ritzpair().
// There we move the smallest values to the proper locations.
template <typename eT>
struct SortingTarget<eT, EigsSelect::BOTH_ENDS> {
  arma_inline static eT get(const eT& val) { return -val; }
};

// specialisation for SMALLEST_MAGN: this covers [float, double, complex] x
// [SMALLEST_MAGN]
template <typename eT>
struct SortingTarget<eT, EigsSelect::SMALLEST_MAGN> {
  arma_inline static typename get_pod_type<eT>::result get(const eT& val) {
    return std::abs(val);
  }
};

// specialisation for SMALLEST_REAL: this covers [complex] x [SMALLEST_REAL]
template <typename T>
struct SortingTarget<std::complex<T>, EigsSelect::SMALLEST_REAL> {
  arma_inline static T get(const std::complex<T>& val) { return val.real(); }
};

// specialisation for SMALLEST_IMAG: this covers [complex] x [SMALLEST_IMAG]
template <typename T>
struct SortingTarget<std::complex<T>, EigsSelect::SMALLEST_IMAG> {
  arma_inline static T get(const std::complex<T>& val) { return std::abs(val.imag()); }
};

// specialisation for SMALLEST_ALGE: this covers [float, double] x [SMALLEST_ALGE]
template <typename eT>
struct SortingTarget<eT, EigsSelect::SMALLEST_ALGE> {
  arma_inline static eT get(const eT& val) { return val; }
};

// Sort eigenvalues and return the order index
template <typename PairType>
struct PairComparator {
  arma_inline bool operator()(const PairType& v1, const PairType& v2) {
    return v1.first < v2.first;
  }
};

template <typename eT, int SelectionRule>
class SortEigenvalue {
 private:
  typedef typename get_pod_type<eT>::result
      TargetType;  // type of the sorting target, will be a floating number type, eg.
                   // double
  typedef std::pair<TargetType, uword>
      PairType;  // type of the sorting pair, including the sorting target and the index

  std::vector<PairType> pair_sort;

 public:
  inline SortEigenvalue(const eT* start, const uword size) : pair_sort(size) {
    arma_debug_sigprint();

    for (uword i = 0; i < size; i++) {
      pair_sort[i].first = SortingTarget<eT, SelectionRule>::get(start[i]);
      pair_sort[i].second = i;
    }

    PairComparator<PairType> comp;

    std::sort(pair_sort.begin(), pair_sort.end(), comp);
  }

  inline std::vector<uword> index() {
    arma_debug_sigprint();

    const uword len = pair_sort.size();

    std::vector<uword> ind(len);

    for (uword i = 0; i < len; i++) {
      ind[i] = pair_sort[i].second;
    }

    return ind;
  }
};

}  // namespace newarp
