//////////////
// Name   : memory_hog
// Author : Chris Koeritz
//////////////
// Copyright (c) 2012-$now By Author.  This program 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:
//     http://www.gnu.org/licenses/gpl.html
// or under the terms of the GNU Library license:
//     http://www.gnu.org/licenses/lgpl.html
// at your preference.  Those licenses describe your legal rights to this
// software, and no other rights or warranties apply.
// Please send updates for this code to: fred@gruntose.com -- Thanks, fred.
//////////////

//! This application lives to grub up lots of memory.
/*!
  You can specify how much memory the application should consume.
  Occasionally it will riffle through its hamstered away memory to try to
  ensure that it stays in real memory rather than virtual memory.
*/

#include <application/hoople_main.h>
#include <application/command_line.h>
#include <application/singleton_application.h>
#include <basis/enhance_cpp.h>
#include <loggers/program_wide_logger.h>
#include <structures/static_memory_gremlin.h>
#include <unit_test/unit_base.h>

using namespace application;
using namespace basis;
using namespace loggers;
//using namespace processes;
using namespace structures;
using namespace unit_test;

const int MEMORY_CHECKING_INTERVAL = 0.5 * SECOND_ms;
  // this many milliseconds elapses between checks on shutdown conditions.

#define BASE_LOG(to_print) EMERGENCY_LOG(program_wide_logger().get(), astring(to_print))
#define LOG(to_print) CLASS_EMERGENCY_LOG(program_wide_logger().get(), astring(to_print))
  // define a macro that will send diagnostic output to the app's logger.

//////////////

class application_example : virtual public unit_base, virtual public application_shell
{
public:
  application_example();
  ~application_example();

  DEFINE_CLASS_NAME("application_example");

  virtual void handle_timer();
    //!< called by timer events from anchor window.

  virtual void handle_startup();
    //!< begins our service's activity.

  virtual void handle_shutdown();
    //!< catches the graceful shutdown so our objects get closed normally.

  virtual int execute();
    //!< the root of the program's activity.

  int print_instructions();
    //!< describes the available command line options for the ULS.

private:
  singleton_application _app_lock;  //!< our inter-application synchronizer.
};

//////////////

application_example::application_example()
: application_shell(),
  _app_lock(static_class_name())
{}

application_example::~application_example()
{}

int application_example::print_instructions()
{
  FUNCDEF("print_instructions");
  BASE_LOG("\
\nUsage: memory_hog {memorySize}\n\
\n\
  This application will consume a requested amount of memory until either\n\
(1) the applications is interrupted or terminated, or (2) the application\n\
is no longer given memory when it requests it (whether due to account limits\n\
or to a lack of remaining allocatable memory), or (3) the requested amount\n\
has been allocated.\n\
  The application will then sit back idly and occasionally riffle through its\n\
big bag of memory in an attempt to keep most of it in physical memory rather\n\
than virtual memory.\n\
  This is not a hostile act unless used unwisely; this program is intended\n\
to get an unloaded machine into a predictable memory state.\n\
  **DO NOT use this program without system administrator permission.**"
);
  return 1;
}

void application_example::handle_startup()
{
  FUNCDEF("handle_startup");
  LOG("starting up now.");
}

void application_example::handle_shutdown()
{
  FUNCDEF("handle_shutdown");
  LOG("shutting down now.");
}

void application_example::handle_timer()
{
  FUNCDEF("handle_timer");
  LOG("timer blip.");
}

int application_example::execute()
{
  FUNCDEF("execute");
  command_line cmds(_global_argc, _global_argv);

LOG(a_sprintf("cmd line has %d entries", cmds.entries()));

  if (cmds.entries() < 1) {
    BASE_LOG("You need to provide a number on the command line....");
    return print_instructions();
  }

  astring size_as_text = cmds.get(0).text();

LOG(a_sprintf("hoo hah!  got a text thingy of: %s", size_as_text.s()));

  if (size_as_text.find('.') < 0) {
    // we don't see this as floating point, but we will move on as if it's
    // an integer and can become floating point.
    size_as_text += ".0";
  }

  double how_fat = size_as_text.convert(double(0.0));

LOG(a_sprintf("got a number from user of: %f", how_fat));

//okay, now that we've got that handled,
// we want to have a hash table of byte arrays.
//   int hash or whatever?  we want it indexable and fast access on a unique id.
// that will be our consumption tactic.
// we will allocate some chunk size in the byte arrays.  maybe max of a meg.
// then we just add as many byte arrays as we need to to get to the requested amount.
// don't just allocate them all at the same size; vary it a bunch, like say 20% of
//   our maximum allotance.
// so randomly pull memory until we get what we want.
// if we get a memory failure, slack off until we can try to get more.
// if we cannot get memory within certain number of failures, report this and bail out.
//   we do not want to crash the machine.
// once we've got our memory, start playing with it.
// every so often,
//   pick a random number of items to play with,
//     go to each item (which is a byte array),
//       pick a random segment of the byte array to look at,
//         read the contents of the memory there.  that's it, nothing stressful.
// repeat the memory play until forever.
//   enhancement, allow them to provide a run time.  time out after that elapses.

  return 0;
}

//////////////

HOOPLE_MAIN(application_example, )