    // Copyright (C) 2011  Davis E. King (davis@dlib.net)
    // License: Boost Software License   See LICENSE.txt for the full license.
    #ifndef DLIB_SEQUENCE_LAbELER_H_h_
    #define DLIB_SEQUENCE_LAbELER_H_h_

    #include "sequence_labeler_abstract.h"
    #include "../matrix.h"
    #include <vector>
    #include "../optimization/find_max_factor_graph_viterbi.h"

    namespace dlib
    {

    // ----------------------------------------------------------------------------------------

        namespace fe_helpers
        {
            template <typename EXP>
            struct dot_functor
            {
                dot_functor(const matrix_exp<EXP>& lambda_) : lambda(lambda_), value(0) {}

                inline void operator() (
                    unsigned long feat_index
                )
                {
                    value += lambda(feat_index);
                }

                inline void operator() (
                    unsigned long feat_index,
                    double feat_value
                )
                {
                    value += feat_value*lambda(feat_index);
                }

                const matrix_exp<EXP>& lambda;
                double value;
            };

            template <typename feature_extractor, typename EXP, typename sequence_type, typename EXP2>
            double dot(
                const matrix_exp<EXP>& lambda,
                const feature_extractor& fe,
                const sequence_type& sequence,
                const matrix_exp<EXP2>& candidate_labeling,
                unsigned long position
            )
            {
                dot_functor<EXP> dot(lambda);
                fe.get_features(dot, sequence, candidate_labeling, position);
                return dot.value;
            }

        }

    // ----------------------------------------------------------------------------------------

        namespace impl
        {
            DLIB_MAKE_HAS_MEMBER_FUNCTION_TEST(
                has_reject_labeling,
                bool,
                template reject_labeling<matrix<unsigned long> >,
                (const typename T::sequence_type&, const matrix_exp<matrix<unsigned long> >&, unsigned long)const
            );

            template <typename feature_extractor, typename EXP, typename sequence_type>
            typename enable_if<has_reject_labeling<feature_extractor>,bool>::type call_reject_labeling_if_exists (
                const feature_extractor& fe,
                const sequence_type& x,
                const matrix_exp<EXP>& y,
                unsigned long position
            )
            {
                return fe.reject_labeling(x, y, position);
            }

            template <typename feature_extractor, typename EXP, typename sequence_type>
            typename disable_if<has_reject_labeling<feature_extractor>,bool>::type call_reject_labeling_if_exists (
                const feature_extractor& ,
                const sequence_type& ,
                const matrix_exp<EXP>& ,
                unsigned long
            )
            {
                return false;
            }
        }

    // ----------------------------------------------------------------------------------------
    // ----------------------------------------------------------------------------------------

        template <
            typename feature_extractor
            >
        typename enable_if<dlib::impl::has_reject_labeling<feature_extractor>,bool>::type contains_invalid_labeling (
            const feature_extractor& fe,
            const typename feature_extractor::sequence_type& x,
            const std::vector<unsigned long>& y
        )
        {
            if (x.size() != y.size())
                return true;

            matrix<unsigned long,0,1> node_states;

            for (unsigned long i = 0; i < x.size(); ++i)
            {
                node_states.set_size(std::min(fe.order(),i) + 1);
                for (unsigned long j = 0; j < (unsigned long)node_states.size(); ++j)
                    node_states(j) = y[i-j];

                if (fe.reject_labeling(x, node_states, i))
                    return true;
            }

            return false;
        }

    // ----------------------------------------------------------------------------------------

        template <
            typename feature_extractor
            >
        typename disable_if<dlib::impl::has_reject_labeling<feature_extractor>,bool>::type contains_invalid_labeling (
            const feature_extractor& ,
            const typename feature_extractor::sequence_type& x,
            const std::vector<unsigned long>& y
        )
        {
            if (x.size() != y.size())
                return true;

            return false;
        }

    // ----------------------------------------------------------------------------------------

        template <
            typename feature_extractor
            >
        bool contains_invalid_labeling (
            const feature_extractor& fe,
            const std::vector<typename feature_extractor::sequence_type>& x,
            const std::vector<std::vector<unsigned long> >& y
        )
        {
            if (x.size() != y.size())
                return true;

            for (unsigned long i = 0; i < x.size(); ++i)
            {
                if (contains_invalid_labeling(fe,x[i],y[i]))
                    return true;
            }
            return false;
        }

    // ----------------------------------------------------------------------------------------
    // ----------------------------------------------------------------------------------------

        template <
            typename feature_extractor
            >
        class sequence_labeler
        {
        public:
            typedef typename feature_extractor::sequence_type sample_sequence_type;
            typedef std::vector<unsigned long> labeled_sequence_type;

        private:
            class map_prob
            {
            public:
                unsigned long order() const { return fe.order(); }
                unsigned long num_states() const { return fe.num_labels(); }

                map_prob(
                    const sample_sequence_type& x_,
                    const feature_extractor& fe_,
                    const matrix<double,0,1>& weights_
                ) :
                    sequence(x_),
                    fe(fe_),
                    weights(weights_)
                {
                }

                unsigned long number_of_nodes(
                ) const
                {
                    return sequence.size();
                }

                template <
                    typename EXP
                    >
                double factor_value (
                    unsigned long node_id,
                    const matrix_exp<EXP>& node_states
                ) const
                {
                    if (dlib::impl::call_reject_labeling_if_exists(fe, sequence,  node_states, node_id))
                        return -std::numeric_limits<double>::infinity();

                    return fe_helpers::dot(weights, fe, sequence, node_states, node_id);
                }

                const sample_sequence_type& sequence;
                const feature_extractor& fe;
                const matrix<double,0,1>& weights;
            };
        public:

            sequence_labeler()
            {
                weights.set_size(fe.num_features());
                weights = 0;
            }

            explicit sequence_labeler(
                const matrix<double,0,1>& weights_
            ) :
                weights(weights_)
            {
                // make sure requires clause is not broken
                DLIB_ASSERT(fe.num_features() == static_cast<unsigned long>(weights_.size()),
                    "\t sequence_labeler::sequence_labeler(weights_)"
                    << "\n\t These sizes should match"
                    << "\n\t fe.num_features(): " << fe.num_features()
                    << "\n\t weights_.size():   " << weights_.size()
                    << "\n\t this: " << this
                    );
            }

            sequence_labeler(
                const matrix<double,0,1>& weights_,
                const feature_extractor& fe_
            ) :
                fe(fe_),
                weights(weights_)
            {
                // make sure requires clause is not broken
                DLIB_ASSERT(fe_.num_features() == static_cast<unsigned long>(weights_.size()),
                    "\t sequence_labeler::sequence_labeler(weights_,fe_)"
                    << "\n\t These sizes should match"
                    << "\n\t fe_.num_features(): " << fe_.num_features()
                    << "\n\t weights_.size():    " << weights_.size()
                    << "\n\t this: " << this
                    );
            }

            const feature_extractor& get_feature_extractor (
            ) const { return fe; }

            const matrix<double,0,1>& get_weights (
            ) const { return weights; }

            unsigned long num_labels (
            ) const { return fe.num_labels(); }

            labeled_sequence_type operator() (
                const sample_sequence_type& x
            ) const
            {
                // make sure requires clause is not broken
                DLIB_ASSERT(num_labels() > 0,
                    "\t labeled_sequence_type sequence_labeler::operator()(x)"
                    << "\n\t You can't have no labels."
                    << "\n\t this: " << this
                    );

                labeled_sequence_type y;
                find_max_factor_graph_viterbi(map_prob(x,fe,weights), y);
                return y;
            }

            void label_sequence (
                const sample_sequence_type& x,
                labeled_sequence_type& y
            ) const
            {
                // make sure requires clause is not broken
                DLIB_ASSERT(num_labels() > 0,
                    "\t void sequence_labeler::label_sequence(x,y)"
                    << "\n\t You can't have no labels."
                    << "\n\t this: " << this
                    );

                find_max_factor_graph_viterbi(map_prob(x,fe,weights), y);
            }

        private:

            feature_extractor fe;
            matrix<double,0,1> weights;
        };

    // ----------------------------------------------------------------------------------------

        template <
            typename feature_extractor
            >
        void serialize (
            const sequence_labeler<feature_extractor>& item,
            std::ostream& out
        )
        {
            serialize(item.get_feature_extractor(), out);
            serialize(item.get_weights(), out);
        }

    // ----------------------------------------------------------------------------------------

        template <
            typename feature_extractor
            >
        void deserialize (
            sequence_labeler<feature_extractor>& item,
            std::istream& in
        )
        {
            feature_extractor fe;
            matrix<double,0,1> weights;

            deserialize(fe, in);
            deserialize(weights, in);

            item = sequence_labeler<feature_extractor>(weights, fe);
        }

    // ----------------------------------------------------------------------------------------

    }

    #endif // DLIB_SEQUENCE_LAbELER_H_h_