// Copyright 2005-2024 Google LLC
//
// 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.
//
// See www.openfst.org for extensive documentation on this weighted
// finite-state transducer library.
//
// Commonly used FST arc types.

#ifndef FST_ARC_H_
#define FST_ARC_H_

#include <climits>
#include <cstddef>
#include <cstdint>
#include <ostream>
#include <string>
#include <type_traits>
#include <utility>

#include <fst/error-weight.h>
#include <fst/expectation-weight.h>
#include <fst/float-weight.h>
#include <fst/fst-decl.h>  // For optional argument declarations
#include <fst/lexicographic-weight.h>
#include <fst/port.h>
#include <fst/power-weight.h>
#include <fst/product-weight.h>
#include <fst/signed-log-weight.h>
#include <fst/sparse-power-weight.h>
#include <fst/string-weight.h>

namespace fst {

// Annotate with FST_LTO_VISIBILITY_PUBLIC to suppress Clang's whole program
// devirtualization optimization. See b/392633566 for context.
template <class W, class L /* = int */, class S /* = int */>
struct FST_LTO_VISIBILITY_PUBLIC ArcTpl {
 public:
  using Weight = W;
  using Label = L;
  using StateId = S;

  Label ilabel;
  Label olabel;
  Weight weight;
  StateId nextstate;

  ArcTpl() noexcept(std::is_nothrow_default_constructible_v<Weight>) = default;

  template <class T>
  ArcTpl(Label ilabel, Label olabel, T&& weight, StateId nextstate)
      : ilabel(ilabel),
        olabel(olabel),
        weight(std::forward<T>(weight)),
        nextstate(nextstate) {}

  // Arc with weight One.
  ArcTpl(Label ilabel, Label olabel, StateId nextstate)
      : ArcTpl(ilabel, olabel, Weight::One(), nextstate) {}

  static const std::string& Type() {
    static const auto* const type = new std::string(
        Weight::Type() == "tropical" ? "standard" : Weight::Type());
    return *type;
  }

  friend std::ostream& operator<<(std::ostream& strm, const ArcTpl& arc) {
    // All weights support operator<<(ostream&).
    strm << arc.Type() << " ilab: " << arc.ilabel << " olab: " << arc.olabel
         << " w: " << arc.weight << " next: " << arc.nextstate;
    return strm;
  }
};

using StdArc = ArcTpl<TropicalWeight>;
using LogArc = ArcTpl<LogWeight>;
using Log64Arc = ArcTpl<Log64Weight>;
using RealArc = ArcTpl<RealWeight>;
using Real64Arc = ArcTpl<Real64Weight>;
using SignedLogArc = ArcTpl<SignedLogWeight>;
using SignedLog64Arc = ArcTpl<SignedLog64Weight>;
using ErrorArc = ArcTpl<ErrorWeight>;
using MinMaxArc = ArcTpl<MinMaxWeight>;

// Arc with integer labels and state IDs and string weights.
template <StringType S = STRING_LEFT>
struct StringArc : public ArcTpl<StringWeight<int, S>> {
 public:
  using Base = ArcTpl<StringWeight<int, S>>;

  using Base::Base;

  static const std::string& Type() {
    static const auto* const type = new std::string(
        S == STRING_LEFT ? "left_standard_string"
                         : (S == STRING_RIGHT ? "right_standard_string"
                                              : "restricted_standard_string"));
    return *type;
  }
};

// Arc with label and state Id type the same as template arg and with
// weights over the Gallic semiring w.r.t the output labels and weights of A.
template <class A, GallicType G = GALLIC_LEFT>
struct GallicArc : public ArcTpl<GallicWeight<int, typename A::Weight, G>,
                                 typename A::Label, typename A::StateId> {
  using Base = ArcTpl<GallicWeight<int, typename A::Weight, G>,
                      typename A::Label, typename A::StateId>;
  using Arc = A;

  using Base::Base;

  explicit GallicArc(const Arc& arc)
      : Base(arc.ilabel, arc.ilabel, Weight(arc.olabel, arc.weight),
             arc.nextstate) {}

  static const std::string& Type() {
    static const auto* const type = new std::string(
        (G == GALLIC_LEFT
             ? "left_gallic_"
             : (G == GALLIC_RIGHT
                    ? "right_gallic_"
                    : (G == GALLIC_RESTRICT
                           ? "restricted_gallic_"
                           : (G == GALLIC_MIN ? "min_gallic_" : "gallic_")))) +
        Arc::Type());
    return *type;
  }
};

// Arc with the reverse of the weight found in its template arg.
template <class A>
struct ReverseArc : public ArcTpl<typename A::Weight::ReverseWeight,
                                  typename A::Label, typename A::StateId> {
  using Base = ArcTpl<typename A::Weight::ReverseWeight, typename A::Label,
                      typename A::StateId>;
  using Arc = A;

  using Base::Base;

  static const std::string& Type() {
    static const auto* const type = new std::string("reverse_" + Arc::Type());
    return *type;
  }
};

// Arc with integer labels and state IDs and lexicographic weights.
template <class Weight1, class Weight2>
using LexicographicArc = ArcTpl<LexicographicWeight<Weight1, Weight2>>;

// Arc with integer labels and state IDs and product weights.
template <class Weight1, class Weight2>
using ProductArc = ArcTpl<ProductWeight<Weight1, Weight2>>;

// Arc with label and state ID type the same as first template argument and with
// weights over the n-th Cartesian power of the weight type of the template
// argument.
template <class A, size_t n>
struct PowerArc : public ArcTpl<PowerWeight<typename A::Weight, n>,
                                typename A::Label, typename A::StateId> {
  using Base = ArcTpl<PowerWeight<typename A::Weight, n>, typename A::Label,
                      typename A::StateId>;
  using Arc = A;

  using Base::Base;

  static const std::string& Type() {
    static const auto* const type =
        new std::string(Arc::Type() + "_^" + std::to_string(n));
    return *type;
  }
};

// Arc with label and state ID type the same as first template argument and with
// weights over the arbitrary Cartesian power of the weight type.
template <class A, class K = int>
struct SparsePowerArc : public ArcTpl<SparsePowerWeight<typename A::Weight, K>,
                                      typename A::Label, typename A::StateId> {
  using Base = ArcTpl<SparsePowerWeight<typename A::Weight, K>,
                      typename A::Label, typename A::StateId>;
  using Arc = A;

  using Base::Base;

  static const std::string& Type() {
    static const std::string* const type = [] {
      std::string type = Arc::Type() + "_^n";
      if (sizeof(K) != sizeof(uint32_t)) {
        type += "_" + std::to_string(CHAR_BIT * sizeof(K));
      }
      return new std::string(type);
    }();
    return *type;
  }
};

// Arc with label and state ID type the same as first template argument and with
// expectation weight over the first template argument's weight type and the
// second template argument.
template <class A, class X2>
struct ExpectationArc : public ArcTpl<ExpectationWeight<typename A::Weight, X2>,
                                      typename A::Label, typename A::StateId> {
  using Base = ArcTpl<ExpectationWeight<typename A::Weight, X2>,
                      typename A::Label, typename A::StateId>;
  using Arc = A;
  using X1 = typename Arc::Weight;

  using Base::Base;

  static const std::string& Type() {
    static const auto* const type =
        new std::string("expectation_" + Arc::Type() + "_" + X2::Type());
    return *type;
  }
};

}  // namespace fst

#endif  // FST_ARC_H_
