#include <ICOMETLog.hxx>
#include <IOADatabase.hxx>
#include <IGeomIdManager.hxx>
#include <ICOMETInput.hxx>

#include <TRandom3.h>
#include <TPolyMarker3D.h>
#include <TPointSet3D.h>
#include <TVector3.h>
#include <TGeoNode.h>
#include <TGeoVolume.h>
#include <TGeoShape.h>
#include <TGeoBBox.h>
#include <TGeoManager.h>

#include <cstdlib>
#include <ios>
#include <sstream>
#include <string>
#include <map>
#include <utility>

#include <IGeomTools.hxx>

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

bool operator<(const TVector3& left, const TVector3& right){
    return left.X() < right.X() ||
        (left.X() == right.X() && 
         (left.Y() < right.Y() || 
          (left.Y() == right.Y() && 
           left.Z() < right.Z())));
}

std::ostream& operator<<(std::ostream& stream,const TVector3& vect){
    return stream<<"("<<vect.X()<<", "<<vect.Y()<<", "<<vect.Z()<<")";
}

std::ostream& operator<<(std::ostream& stream,
                         const COMET::GeomTools::PointPair& pair){
    return stream<<pair.toString();
}

std::ostream& operator<<(std::ostream& stream,
                         const COMET::GeomTools::PointDetails& details){
    return stream<<details.toString();
}

namespace COMET {
namespace GeomTools {

    TGeoManager* FetchGeometry(COMET::ICOMETInput* file,std::string filename,std::string test_volume){
        // Make sure file is valid (not null etc)
        if(!file || !file->IsAttached()){
            COMETError("Bad input file: "<<filename);
            return NULL;
        }

        // Get the geometry from the file
        COMET::IOADatabase::Get().GeomId().LoadGeometry(*file->GetFilePointer());
        TGeoManager* geometry=gGeoManager;
        if(!geometry){
            COMETError("Cannot fetch geometry from file: "<<filename);
            return NULL;
        }

        // Does the file contain the named node (if requested)
        if (!test_volume.empty()){
            if(geometry->CheckPath(test_volume.c_str())){
                geometry->cd(test_volume.c_str());
            }else{
                COMETError("Cannot find requested volume: "<<test_volume);
                file->Close();
                delete file;
                return NULL;
            }
        }
        return geometry;
    }

    bool ScanFirstGeometry(TGeoManager* geometry,
                           PointSelector* selector,
                           PointDetailsList& outList){
        gGeoManager=geometry;

        cout<<"Scanning first geometry: "<<endl;
        TVector3 point = TVector3();
        int i = 0;
        while (selector->GetNextPoint(point, true)){
            TGeoNode* volume=GetNode(geometry,point);
            COMETNamedTrace("FirstScan","point ["<< i<<"]: "<<point
                                      <<" name: "<<volume->GetName()
                                      <<", "<<volume->GetVolume()->GetTitle());
            outList[point].first=PointDetails(volume);
            i++;
        }
        return true;
    }

    bool ScanSecondGeometry(TGeoManager* geometry,PointDetailsList& outList,PointDiffLists& outDiff){
        gGeoManager=geometry;

        cout<<"Scanning second geometry: "<<endl;
        int tenPerCent=outList.size()/10;
        int i=0;
        for(PointDetailsList::iterator i_point=outList.begin();
                i_point!=outList.end(); ++i_point){
            const TVector3& point=i_point->first;
            TGeoNode* volume=GetNode(geometry,point);
            if(!volume) i_point->second.second=PointDetails();
            else i_point->second.second=PointDetails(volume);

            const PointDetails& inGeom_one=i_point->second.first;
            const PointDetails& inGeom_two=i_point->second.second;

            if(inGeom_one != inGeom_two){
                outDiff.AddDiff(point,PointPair(inGeom_one,inGeom_two));
            }
            if(i%tenPerCent==0) cout<<" "<<i/tenPerCent*10<<"% complete"<<endl;
            ++i;
        }
        return true;
    }

    bool PrintDetailList(PointDetailsList& outList, 
                         bool printFirst, 
                         bool printSecond){

        for(PointDetailsList::iterator i_point=outList.begin();
                i_point!=outList.end(); ++i_point){
            const TVector3& point=i_point->first;
            const PointDetails& inGeom_one=i_point->second.first;
            const PointDetails& inGeom_two=i_point->second.second;
            cout << "Position : " << point;
            if (printFirst && printSecond) 
                cout << " Vol 1: " << inGeom_one 
                     << ", Vol 2: " << inGeom_two;
            else if (printFirst) cout << " Vol: " << inGeom_one;
            else if (printSecond) cout << " Vol: " << inGeom_two;
            cout << endl;
        }
        return true;
    }

    void PrintDiff(const PointDiffLists& allDiffLists, bool everything){
        cout<<"Number of points identified as having changed: "<<allDiffLists.size()<<endl;
        int count=1;
        std::map<int,int> severityTally;
        std::map<std::string,int> occurrenceTally;
        for(PointDiffLists::const_iterator i_list=allDiffLists.begin();
               i_list!=allDiffLists.end(); ++i_list){
            for(PointDetailsList::const_iterator i_point=i_list->begin();
                    i_point!=i_list->end(); ++i_point){
                std::string difference=i_point->second.toString();
                if (everything)
                    cout<<"Point ["<<count<<"]: "<<i_point->first<<" => "<<difference<<endl;
                ++occurrenceTally[difference];
                ++severityTally[i_point->second.GetDifferenceSeverity()];
                ++count;
            }
        }
        if(severityTally.empty()) return;

        cout<<"Summary of differences: "<<endl;
        std::multimap<int,std::string> sortedOccurenceTally;
        for(std::map<std::string,int>::const_iterator i_type= occurrenceTally.begin();
                i_type!=occurrenceTally.end();++i_type){
            sortedOccurenceTally.insert(std::make_pair(i_type->second,i_type->first));
        }
        for(std::multimap<int,std::string>::const_iterator i_type= sortedOccurenceTally.begin();
                i_type!=sortedOccurenceTally.end();++i_type){
            cout<<" * "<<i_type->first<<" point(s) changed as: "<<i_type->second<<endl;
        }

        cout<<"Total summary of differences: "<<endl;
        for(std::map<int,int>::const_iterator i_severity= severityTally.begin();
                i_severity!=severityTally.end();++i_severity){
            std::string changed;
            if(i_severity->first & PointPair::kPathName) changed+="path_name";
            if(i_severity->first & PointPair::kMaterial) changed+=(changed.empty()?"":" & ")+std::string("material");
            if(i_severity->first & PointPair::kOverlap)  changed+=(changed.empty()?"":" & ")+std::string("overlap");
            cout<<" * "<<i_severity->second<<" points had changes to "<<changed<<endl;
        }
    }

    bool SaveEverything(const std::string& output_file, const PointDiffLists& pointDiffs, const PointDetailsList& pointDetails){
        TFile* outfile=TFile::Open(output_file.c_str(),"recreate");
        if(!outfile || outfile->IsZombie()){
            cout<<"Cannot create output file: "<<output_file<<endl;
            return false;
        }
        cout<<"Saving diffs" <<endl;
        for(PointDiffLists::const_iterator i_list=pointDiffs.begin();
                i_list!=pointDiffs.end(); ++i_list){
        int severity=i_list-pointDiffs.begin();
            int color=pointDiffs.SeverityColour(severity);
            SavePoints(*i_list,8,color);
        }
        cout<<"Saving all sampled points" <<endl;
        SavePoints(pointDetails,1,1,"AllPoints");
        gGeoManager->Write();
        outfile->Write();
        outfile->Close();
        return true;
    }

    void SavePoints(const PointDetailsList& list,int style, int colour, std::string name){

       if(list.empty()) return;

        TPolyMarker3D *marker = new TPolyMarker3D();
        //TPointSet3D *marker = new TPointSet3D();
        marker->SetMarkerStyle(style);
        marker->SetMarkerColor(colour);
        int count=0;
        for(PointDetailsList::const_iterator i_point=list.begin();
                i_point!=list.end(); ++i_point){
            const TVector3& vect=i_point->first;
            marker->SetNextPoint(vect.X(), vect.Y(),vect.Z());
            ++count;
            //std::string description=i_point->second.toString();
            //marker->SetPointId(new TNamed(description.c_str(),description.c_str()));
            if(name.empty()) {
                name=i_point->second.SeverityString();
            }
        }
        marker->Write(name.c_str());
    }

    TGeoNode* GetNode(TGeoManager* geometry, const TVector3& position){
        geometry->PushPath();
        geometry->GetTopNode()->cd();
        TGeoNode* volume=geometry->FindNode(position.X(),position.Y(),position.Z());
        geometry->PopPath();
        return volume;
    }

    PointSelector* BuildPointSelector(const std::string& options,
                                      int totalPoints,
                                      TGeoManager* geom_one){
        // Set the geometry manager
        gGeoManager=geom_one;
        // Get the options as a TString
        TString optionsStr = TString(options);
        optionsStr.ToLower();
        // Split the options string
        SubStrings allOptions;
        SplitString(options, allOptions);
        // Return random daughter points if required
        if (allOptions[0] == "random") 
            return new RandomDaughterPoints(totalPoints, geom_one);
        // Return beamline coordinate points
        else if (allOptions[0] == "beamline")
            return new PointsAlongBeamLine(totalPoints, geom_one);
        // Return points from a file
        else if (allOptions[0] == "fromfile"){
            if (allOptions.size() < 2) 
                COMETError("Need to provide a file name for the \"fromfile\""
                           " selector");
            else return new PointsFromFile(totalPoints, allOptions[1]);
        }
        else COMETError("Unrecognized point selector " << optionsStr);
        // Return null as an error
        return NULL;
    }

    void SplitString(const std::string& inputString, SubStrings& outStrings, char delim){
        // Make a TString copy of the input string
        TString inTString(inputString);
        // Ensure we do not loop forever
        int inf_loop = 0;
        // Keep splitting on white space delimieters
        while (!inTString.IsNull()) {
            // Trim leading or trailing white space, so we can cut on an aribitrary 
            // amount of white space
            inTString.Remove(TString::kBoth, delim);
            // Find the first new white space
            int firstPos = inTString.First(delim);
            if (inTString.CountChar(delim) == 0) firstPos = inTString.Length();
            // Make a substring up to this point
            TString nextName = inTString(0, firstPos);
            outStrings.push_back(nextName.Data());
            // Remove this sub string from the copy of the input name
            inTString.Remove(0,firstPos);
            // If we hit an infinite loop, something is VERY wrong
            inf_loop++;
            if (inf_loop > 50) {
                COMETError("Infinite loop when trying to split \"" 
                           << inputString << "\"");
                // Lazy error throwing
                throw;
            }
        }
    }
}
}