// Test to load field map and dump out field at a point

#include <iostream>
#include <sstream>
#include <cmath>

#include "IFieldManager.hxx"
#include "IFieldMap.hxx"
#include "IFieldMapList.hxx"
#include "IFieldPlotter.hxx"
#include "IFieldMapLoader.hxx"
#include <IFieldDescription.hxx>
#include <ICOMETLog.hxx>

#include "Rtypes.h"
#include "TVector3.h"
#include "TFile.h"
#include "TH1.h"
#include "TH2.h"
#include "TRotation.h"

using std::cout;
using std::endl;

std::ostream& operator<<(std::ostream& stream,const TVector3& vect){
    stream<<"("<<vect.x()<<", "<<vect.y()<<", "<<vect.z() <<")";
    return stream;
}

void Usage(const char* prog, std::string inputOptsUsage){
    cout<<"Usage: "<<prog<<" [options]\n"
          "Plots a planar section (or sections) through an ICEDUST fieldmap.\n"
          "Use the input file options to specify and place fieldmap files and output file\n"
          "options to control the field drawing and output histograms.\n"
          "\n" << inputOptsUsage << "\n"
          "Output file Options: \n"
          " -O <filename>    Set the output filename.  \n"
          " -o <origin>      Set the centre of the plane to draw from (in input file units, typically mm).  \n"
          " -u <up_vector>   Set the up-vector for the output plane.  Used to define the output plot's y-axis.  \n"
          " -N <normal>      Set the normal of the plane to work in.  \n"
          " -n <num_steps>   Set the number of steps to used in either direction  \n"
          " -d <step_size>   Set the step size (in input file units, typically mm) \n"
          " -p <n_planes>    Set the number of planes to scan through \n"
          "\n"
          "Examples: \n"
          "Load in three fieldmap files and flip the field for each one.\n"
          "Then plot the field looking down onto the X-Z plane and centred at\n"
          "(5600,10,1800) in global ICEDUST coordinates, in steps of 10 mm, with 610\n"
          "points in either direction (ie. 1220 points for each dimension). \n"
          "\n"
          "     oaEMField_PlotFieldMaps.exe -f seg_1.map -s-1 -f seg_2.map -s-1 -f arc_1.map -s-1  -o '5600 10 1800' -N '0 1 0' -u '0 0 1' -d10 -n610  \n"
          "\n"
          "Reload a field description from a root file (an output oaEvent file or previous "<<prog<<" output).\n"
          "Then plot 5 slices of the field (with default orientation and separation) and store the output histograms to `output.root`\n"
          "\n"
          "     oaEMField_PlotFieldMaps.exe -R field_hists.root -p 5 -O output.root\n"
          "\n"
        <<endl;
}

int main(int argc,char** argv) {
    COMET::ICOMETLog::Configure();

    // Load the loader
    COMET::IFieldMapLoader loader;
    COMET::IFieldPlotter plotter;
    COMET::IFieldMapList* field_list=new COMET::IFieldMapList;
    std::string outfilename="field_hists.root";
    int n_planes=1;
    double plane_sep=10; //Internal field map units, typically mm
    for (;;) {
        std::string optString = "h?"+loader.GetOptString()+"O:o:u:N:n:d:p:";
        char c = getopt(argc, argv, optString.c_str());
        std::stringstream stream;
        if(optarg) stream.str(optarg);
        // Try to process it in the loader
        int inputArg = loader.ProcessArgument(c, optarg, field_list);
        // Success
        if (inputArg == 0) continue;
        // Bad argument, pass to main
        else if (inputArg == 1 || inputArg == 2) return inputArg;
        // Otherwise, process here
        else if (inputArg == 3){
            if (c<0) break;
            switch (c) {
                case 'o':
                    {
                        double vect[3];
                        stream>>vect[0]>>vect[1]>>vect[2];
                        plotter.SetOrigin(vect[0],vect[1],vect[2]);
                        break;
                    }
                case 'N':
                    {
                        double vect[3];
                        stream>>vect[0]>>vect[1]>>vect[2];
                        plotter.SetNormal(vect[0],vect[1],vect[2]);
                        break;
                    }
                case 'u':
                    {
                        double vect[3];
                        stream>>vect[0]>>vect[1]>>vect[2];
                        plotter.SetUpVector(vect[0],vect[1],vect[2]);
                        break;
                    }
                case 'n':
                    {
                        int n_steps=0;
                        stream>>n_steps;
                        plotter.SetNSteps(n_steps);
                        break;
                    }
                case 'O':
                    {
                        stream>>outfilename;
                        break;
                    }
                case 'p':
                    {
                        stream>>n_planes;
                        break;
                    }
                case 'd':
                    {
                        double step_size;
                        stream>>step_size;
                        plotter.SetStepSize(step_size);
                        break;
                    }
                case 'h':case '?':
                    Usage(argv[0], loader.UsageMessage());
                    return 0;
                default:
                    cout<<"Error: Unknown option: "<<c<<endl<<endl;
                    Usage(argv[0], loader.UsageMessage());
                    return 1;
            }
        }
        // If the loader failed
        if(inputArg == 4 || stream.fail() || ! stream.eof()){
            cout<<inputArg<<std::endl;
            cout<<"Error: Bad option value: '"<<optarg<<"' for option '"<<c <<"'"<<endl<<endl;
            Usage(argv[0], loader.UsageMessage());
            return 1;
        }
    }

    // Need to init the global field object
    loader.InitAllFields(field_list);

    // Load the output file
    TFile* outfile=TFile::Open(outfilename.c_str(),"recreate");
    plotter.SetDirectory(outfile);
    bool vectors_ok=plotter.Initialise();
    if(!vectors_ok) return 1;

    if(n_planes<=1) plotter.PlotPlane();
    else plotter.PlotPlanes(n_planes,plane_sep);

    loader.WriteAllFields(field_list);
    outfile->Write();
    outfile->Close();

    return 0;
}