#ifndef WCVertex_h
#define WCVertex_h

#include "WCPData/Point.h"
#include "WCPData/MergeSpaceCell.h"
#include "WCPData/WCTrack.h"

//#include "Minuit2/Minuit2Minimizer.h"
//#include "Math/Functor.h"
#include "Minuit2/FCNBase.h"

#include <vector>
#include <map>

namespace WCP {
    class WCVertex {
       public:
        Point Center();
        WCVertex(MergeSpaceCell& msc);
        ~WCVertex();
        void Add(WCTrack* track);
        int get_ntracks() { return tracks.size(); };
        WCTrackSelection& get_tracks() { return tracks; };
        MergeSpaceCell* get_msc() { return msc; };
        void set_msc(MergeSpaceCell* cell) { msc = cell; };
        void set_center(Point& p)
        {
            center.x = p.x;
            center.y = p.y;
            center.z = p.z;
        }

        float center_dist();

        int IsInside(WCVertex* vertex);
        bool AddVertex(WCVertex* vertex, int flag = 1);
        bool CheckContain(MergeSpaceCell* cell);
        WCVertex* OrganizeTracks();
        WCTrackSelection BreakTracks();
        WCTrackSelection BreakTracksAngle(WCTrackSelection& finished_tracks);

        void ProcessTracks(WCTrackSelection& break_tracks);
        void OrganizeEnds(MergeSpaceCellSelection& cells, int flag = 1);
        // static double dis2(const double *xx);
        bool FindVertex(int flag = 0);

        void set_ky(WCTrack* track, double ky);
        void set_kz(WCTrack* track, double kz);

        double get_ky(WCTrack* track);
        double get_kz(WCTrack* track);

        double get_ky(int i) { return tracks_ky.at(i); }
        double get_kz(int i) { return tracks_kz.at(i); }
        int get_fit_type() { return fit_type; };
        bool get_fit_success() { return fit_success; };
        bool get_fit_chi2() { return fit_chi2; };
        void reset_center();

        bool MergeVertex(WCVertex* vertex);

       protected:
        int fit_type;

        bool fit_success;
        double fit_chi2;

        Point center;
        MergeSpaceCell* msc;
        WCTrackSelection tracks;
        std::vector<double> tracks_ky;
        std::vector<double> tracks_kz;
    };

    typedef std::vector<WCVertex*> WCVertexSelection;
    typedef std::map<MergeSpaceCell*, WCVertex*> MSC_WCV_Map;
    // typedef std::map<WCTrack*, WCVertexSelection> WCT_WCVs_Map;

    class MyFCN : public ROOT::Minuit2::FCNBase {
       public:
        double Up() const { return 1.; }

        MyFCN(WCVertex* vertex, int fit_flag)
          : vertex(vertex)
          , fit_flag(fit_flag)
        {
        }

        ~MyFCN() {}

        double operator()(const std::vector<double>& xx) const;
        double get_chi2(const std::vector<double>& xx) const;

       private:
        WCVertex* vertex;
        int fit_flag;
    };

}  // namespace WCP

#endif
