/***************************************************************************
 *   Copyright (C) 2005 by Raphael Langerhorst                             *
 *   raphael-langerhorst@gmx.at                                            *
 *                                                                         *
 *   Permission is hereby granted, free of charge, to any person obtaining *
 *   a copy of this software and associated documentation files (the       *
 *   "Software"), to deal in the Software without restriction, including   *
 *   without limitation the rights to use, copy, modify, merge, publish,   *
 *   distribute, sublicense, and/or sell copies of the Software, and to    *
 *   permit persons to whom the Software is furnished to do so, subject to *
 *   the following conditions:                                             *
 *                                                                         *
 *   The above copyright notice and this permission notice shall be        *
 *   included in all copies or substantial portions of the Software.       *
 *                                                                         *
 *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       *
 *   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    *
 *   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*
 *   IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR     *
 *   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, *
 *   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR *
 *   OTHER DEALINGS IN THE SOFTWARE.                                       *
 ***************************************************************************/

#include "GEnergy.h"

namespace GCS
{

GEnergy::GEnergy()
: Level(0),
  Amount(0),
  Sigma(0)
{
}

GEnergy::GEnergy(double level, double amount, double sigma)
: Level(level),
  Amount(amount),
  Sigma(sigma)
{
}

GEnergy::GEnergy(const GEnergy& original)
: QMutex(),
  Level(original.Level),
  Amount(original.Amount),
  Sigma(original.Sigma)
{
}

GEnergy::~GEnergy()
{
}

double GEnergy::level() const
{
  return Level;
}

double GEnergy::amount() const
{
  return Amount;
}

double GEnergy::sigma() const
{
  return Sigma;
}

void GEnergy::set(double level, double amount, double sigma)
{
  this->Level = level;
  this->Amount = amount;
  this->Sigma = sigma;
}

void GEnergy::set(const GEnergy original)
{
  set(original.Level,original.Amount,original.Sigma);
}

void GEnergy::operator = (const GEnergy& original)
{
  set(original);
}

GEnergy GEnergy::take(double fraction)
{
  if (fraction>1)
    fraction=1;
  double difference = Amount*fraction;
  Amount -= difference;
  return GEnergy(Level,difference,Sigma);
}

void GEnergy::put(const GEnergy& energy)
{
  if (energy.Amount<0)
    return;
    
  double fraction = energy.Amount / (this->Amount + energy.Amount);
  double d_Level = energy.Level - this->Level;
  double d_Sigma = energy.Sigma - this->Sigma;
  
  this->Amount += energy.Amount;
  this->Level += d_Level*fraction;
  
  //@todo: improve sigma addition
  double d_Level_abs = d_Level;
  if (d_Level_abs<0)
    d_Level_abs = -d_Level_abs;
  this->Sigma += (d_Sigma + d_Level_abs)*fraction;
  
  //now the energy is absorbed...
//   energy.Level = this->Level;
//   energy.Amount = 0;
//   energy.Sigma = this->Sigma;
}

}