#ifndef __MR2100_H
#define __MR2100_H

class TMRP_record : public TObject 
{
  TMRP_time _time;         // time 
  real _gross_requirement; // gross req
  real _on_hand;           // projected on hand
  real _sched_receipts;    // scheduled receipts
  real _released_receipts; // released scheduled receipts (not used)
  real _net_requirement;   // lot-sized net requirement
  real _planned_orders;    // anticipated planned orders

public:
  const real& gross_requirement() const { return _gross_requirement; }
  const real& on_hand() const { return _on_hand > ZERO ? _on_hand : ZERO; }
  const real& sched_receipts() const { return _sched_receipts; }
  const real& net_requirement() const { return _net_requirement; }
  const real& planned_orders() const { return _planned_orders; }

  const real& set_on_hand(const real & val) { return _on_hand=val;}
  const real& set_net_req(const real & val) { return _net_requirement=val;}
  const real& add_net_req(const real & val);
  const real& add_gross_req(const real& val);
  const real& add_sched_rec(const real& val);

  TMRP_record & operator=(const TMRP_record & a);

  const TMRP_time& time() const { return _time; }
  virtual TObject* dup() const;

  TMRP_record(const TMRP_time& t);
  virtual ~TMRP_record() { }
};


class TMRP_line : public TSortable
{
  TCodice_articolo _codart;
  TString16 _livgiac;
  TString16 _codmag;
  TString16 _codimp;
  TString16 _codlin;
  long _codcli;
static  TArticolo_giacenza *_articolo_giac;

protected:  
  TArray _req_per_bucket;
  
  TPointer_array _sons;
  TArray _qta_sons;

  TString _description;

  bool is_son(const TCodice_articolo& art) const;

  void lotti_riordino(real & minimo, real & increm) const ;
public:
  TMRP_record& record(int i) const;
  TMRP_record& record(const TMRP_time& t) const;

  const TCodice_articolo& codice() const { return _codart; }
  const TString& livgiac() const { return _livgiac; }
  const TString& codmag() const { return _codmag; }
  const TString& codimp() const { return _codimp; }
  const TString& codlin() const { return _codlin; }
  long codcli() const { return _codcli; }
  const TString& description() const { return _description; }

  virtual int compare(const TSortable& s) const;
  int first_bucket(int i) const { return _req_per_bucket.first(); }
  int last_bucket() const { return _req_per_bucket.last(); }
  int next_bucket(int i) const { return _req_per_bucket.succ(i); }

  int add_son(const real& qta, TMRP_line* son);
  int sons() const { return _sons.items(); }
  const TMRP_line& son(int i) const { return (const TMRP_line&)_sons[i]; }
  TMRP_line& son(int i) { return (TMRP_line&)_sons[i]; }
  const real& qta_son(int i) const { return (const real&)_qta_sons[i]; }

  const real & on_hand(int i)  const 
    {return record(i).on_hand();}

  const real & gross_requirement(int i)  const 
    {return record(i).gross_requirement();}

  const real & net_requirement(int i)  const 
    {return record(i).net_requirement();}

  const real & sched_receipts(int i)  const 
    {return record(i).sched_receipts();}

  const real & planned_orders(int i)  const 
    {return record(i).planned_orders();}

  const TString& set_description(const TString &s) { return _description=s; }

  const real& set_on_hand(int i, const real& val);
  const real& set_on_hand(const TMRP_time& t,  const real& val);

  const real& add_gross_req(const TMRP_time& t, const real& val);
  const real& add_sched_rec(const TMRP_time& t, const real& val);

  const real& add_net_req(const TMRP_time& t, const real& val);
  const real& set_net_req(int i, const real& val);
  real sizeup_net_requirement(int i, const real& val);

  real& giacenza_attuale(real&) const;
  real& giacenza_attuale(real&, const TDate & data_attuale) const;
  real &scorta_minima(real&) const;
  real &scorta_minima(real&, const TDate & data) const;

  const TMRP_time& lead_time(int i, TMRP_time& t) const;

  const TMRP_time& time(int i) const { return record(i).time(); }

  virtual TObject* dup() const;
  TMRP_line & operator=(const TMRP_line & a);
  
  TMRP_line(const char* art, const char* giac, 
            const char* magdep, const char* imp, const char* lin, 
            long codcli);
  TMRP_line(const TMRP_line&a);
  virtual ~TMRP_line() { }
};

class TMRP_lines : public TMRP_array
{
  bool _ignore_mag;
  bool _ignore_imp;
  bool _ignore_lin;

protected:
  virtual TSortable* new_obj(const TToken_string& key) const;

public:
  TMRP_line* find(const TCodice_articolo& codart, 
                  const TString& giac, const TString& mag, 
                  const TString& imp, const TString& lin,
                  long codcli,
                  bool create=FALSE);
  
  TMRP_line& operator[](long n) const 
  { return (TMRP_line&)find_obj(n); }

  void ignore(bool im, bool ii, bool il)
  { _ignore_mag = im; _ignore_imp = ii; _ignore_lin = il; }

  virtual TObject* dup() const;
  TMRP_lines & operator= (const TMRP_lines &a);

  TMRP_lines();
  TMRP_lines(const TMRP_lines &a);
  virtual ~TMRP_lines();
};


#endif