#include "WireCellSigProc/Diagnostics.h"

#include <cmath>
#include <complex>
//#include <iostream>

using namespace WireCell::SigProc;



Diagnostics::Partial::Partial(int nfreqs, double maxpower)
    : nfreqs(nfreqs)
    , maxpower(maxpower)
{
}

bool Diagnostics::Partial::operator()(const WireCell::Waveform::compseq_t& spec) const
{
    const double mag0 = std::abs(spec[0+1]);
    double sum = mag0;
    for (int ind=1; ind<= nfreqs && ind < (int)spec.size(); ++ind) {
	const double magi = std::abs(spec[ind+1]);
	if (mag0 <= magi) {
	    return false;
	}
	sum += magi;
    }
    // if (sum/(nfreqs+1) > maxpower){
    //   std::cout << mag0 << " " << std::abs(spec[2]) << " " << std::abs(spec[3]) << " " << std::abs(spec[4]) << " " << std::abs(spec[5]) << std::endl;
    // }

    return sum/(nfreqs+1) > maxpower;
}


Diagnostics::Chirp::Chirp(int windowSize, double chirpMinRMS, double maxNormalNeighborFrac)
    : windowSize(windowSize)
    , chirpMinRMS(chirpMinRMS)
    , maxNormalNeighborFrac(maxNormalNeighborFrac)
{
}

bool Diagnostics::Chirp::operator()(const WireCell::Waveform::realseq_t& sig, int& beg, int& end) const
{
    beg = end = -1;

    // this alg is from Mike Mooney

    // magic numbers moved into constructor
    //const int windowSize = 20;
    //const double chirpMinRMS = 0.9;
    //const double maxNormalNeighborFrac = 0.20;

    int counter = 0;
    double runningAmpMean = 0.0;
    double runningAmpRMS = 0.0;
    int numLowRMS = 0;
    int firstLowRMSBin = -1;	// computed below assuming
    int lastLowRMSBin = -1;	//  1-based arrays
    bool lowRMSFlag = false;
    double RMSfirst = 0.0;
    double RMSsecond = 0.0;
    double RMSthird = 0.0;
    int numNormalNeighbors = 0;

    const int numBins = sig.size();
   
    for (int ibin = 0; ibin < numBins; ibin++) {

	double ADCval = sig[ibin];

	runningAmpMean += ADCval;
	runningAmpRMS += ADCval*ADCval;
      
	counter++;
	if(counter == windowSize) {

	    runningAmpMean /= (double)windowSize;
	    runningAmpRMS /= (double)windowSize;
	    runningAmpRMS = std::sqrt(runningAmpRMS - runningAmpMean*runningAmpMean);
	  
	    RMSfirst = RMSsecond;
	    RMSsecond = RMSthird;
	    RMSthird = runningAmpRMS;
	  
	    if(runningAmpRMS < chirpMinRMS) {
		numLowRMS++;
	    }
	  
	    if(ibin >= 3*windowSize-1) {
		if((RMSsecond < chirpMinRMS) && ((RMSfirst > chirpMinRMS) || (RMSthird > chirpMinRMS))) {
		    numNormalNeighbors++;
		}
	      
		if(lowRMSFlag == false) {
		    if((RMSsecond < chirpMinRMS) && (RMSthird < chirpMinRMS)) {
			lowRMSFlag = true;
			firstLowRMSBin = ibin - 2*windowSize + 1;
			lastLowRMSBin = ibin - windowSize + 1;
		    }
		  
		    if((ibin == 3*windowSize-1) && (RMSfirst < chirpMinRMS) && (RMSsecond < chirpMinRMS)) {
			lowRMSFlag = true;
			firstLowRMSBin = ibin - 3*windowSize + 1;
			lastLowRMSBin = ibin - 2*windowSize + 1;
		    }
		}
		else {
		    if((RMSsecond < chirpMinRMS) && (RMSthird < chirpMinRMS)) {
			lastLowRMSBin = ibin - windowSize + 1;
		    }
		}
	    }
	    
	    counter = 0;
	    runningAmpMean = 0.0;
	    runningAmpRMS = 0.0;
	}
    }
  
    double chirpFrac = ((double) numLowRMS)/(((double) numBins)/((double) windowSize));
    double normalNeighborFrac = ((double) numNormalNeighbors)/((double) numLowRMS);
    if ( (numLowRMS > 4) &&
	 ((normalNeighborFrac < maxNormalNeighborFrac)
	  || ((numLowRMS < 2.0/maxNormalNeighborFrac)
	      && (lastLowRMSBin-firstLowRMSBin == numLowRMS*windowSize)))
	) {

	firstLowRMSBin = std::max(1, firstLowRMSBin - windowSize);
	lastLowRMSBin = std::min(numBins, lastLowRMSBin + 2*windowSize);
      
	if((numBins-lastLowRMSBin) < windowSize) {
	    lastLowRMSBin = numBins;
	}
      
	if(chirpFrac > 0.99) {
	    firstLowRMSBin = 1;
	    lastLowRMSBin = numBins;
	}
      
	beg = firstLowRMSBin - 1;
	end = lastLowRMSBin;
	return true;
    }
    return false;
}

// Local Variables:
// mode: c++
// c-basic-offset: 4
// End:
