/* -*- c++ -*- */
/*
 * Copyright 2006 Free Software Foundation, Inc.
 * 
 * This file is part of GNU Radio
 * 
 * GNU Radio is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3, or (at your option)
 * any later version.
 * 
 * GNU Radio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with GNU Radio; see the file COPYING.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street,
 * Boston, MA 02110-1301, USA.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <gr_bin_statistics_f.h>
#include <gr_io_signature.h>
#include <string.h>

gr_bin_statistics_f_sptr
gr_make_bin_statistics_f(unsigned int vlen,
			gr_msg_queue_sptr msgq,
			gr_feval_dd *tune,
			size_t tune_delay,
			size_t dwell_delay)
{
  return gr_bin_statistics_f_sptr(new gr_bin_statistics_f(vlen,
							  msgq,
							  tune,
							  tune_delay,
							  dwell_delay));
}

gr_bin_statistics_f::gr_bin_statistics_f(unsigned int vlen,
					 gr_msg_queue_sptr msgq,
					 gr_feval_dd *tune,
					 size_t tune_delay,
					 size_t dwell_delay)
  : gr_sync_block("bin_statistics_f",
		  gr_make_io_signature(1, 1, sizeof(float) * vlen),
		  gr_make_io_signature(0, 0, 0)),
    d_vlen(vlen), d_msgq(msgq), d_tune(tune),
    d_tune_delay(tune_delay), d_dwell_delay(dwell_delay),
    d_center_freq(0), d_delay(0),
    d_max(vlen)
{
  enter_init();
}

gr_bin_statistics_f::~gr_bin_statistics_f()
{
  // NOP
}

void
gr_bin_statistics_f::enter_init()
{
  d_state = ST_INIT;
  d_delay = 0;
}

void
gr_bin_statistics_f::enter_tune_delay()
{
  d_state = ST_TUNE_DELAY;
  d_delay = d_tune_delay;
  d_center_freq = d_tune->calleval(0);
}

void
gr_bin_statistics_f::enter_dwell_delay()
{
  d_state = ST_DWELL_DELAY;
  d_delay = d_dwell_delay;
  reset_stats();
}

void
gr_bin_statistics_f::leave_dwell_delay()
{
  send_stats();
}

int
gr_bin_statistics_f::work(int noutput_items,
			  gr_vector_const_void_star &input_items,
			  gr_vector_void_star &output_items)
{
  const float *input = (const float *) input_items[0];
  size_t vlen = d_max.size();

  int n = 0;
  int t;

  while (n < noutput_items){
    switch (d_state){

    case ST_INIT:
      enter_tune_delay();
      break;

    case ST_TUNE_DELAY:
      t = std::min(noutput_items - n, int(d_delay));
      n += t;
      d_delay -= t;
      assert(d_delay >= 0);
      if (d_delay == 0)
	enter_dwell_delay();
      break;
      
    case ST_DWELL_DELAY:
      t = std::min(noutput_items - n, int(d_delay));
      for (int i = 0; i < t; i++){
	accrue_stats(&input[n * vlen]);
	n++;
      }
      d_delay -= t;
      assert(d_delay >= 0);
      if (d_delay == 0){
	leave_dwell_delay();
	enter_tune_delay();
      }
      break;

    default:
      assert(0);
    }
  }

  return noutput_items;
}

//////////////////////////////////////////////////////////////////////////
//           virtual methods for gathering stats
//////////////////////////////////////////////////////////////////////////

void
gr_bin_statistics_f::reset_stats()
{
  for (size_t i = 0; i < vlen(); i++){
    d_max[i] = 0;
  }
}

void
gr_bin_statistics_f::accrue_stats(const float *input)
{
  for (size_t i = 0; i < vlen(); i++){
    d_max[i] = std::max(d_max[i], input[i]);	// compute per bin maxima
  }
}

void
gr_bin_statistics_f::send_stats()
{
  if (msgq()->full_p())		// if the queue is full, don't block, drop the data...
    return;

  // build & send a message
  gr_message_sptr msg = gr_make_message(0, center_freq(), vlen(), vlen() * sizeof(float));
  memcpy(msg->msg(), &d_max[0], vlen() * sizeof(float));
  msgq()->insert_tail(msg);
}
