//-*- mode: c++; indent-tabs-mode: nil; coding: utf-8; show-trailing-whitespace: t -*-

// file over51.hpp

#ifndef _OVER51_HPP
#define _OVER51_HPP

#include <iostream>
#include <iomanip>
#include <string>
#include <sstream>
#include <limits>
#include <exception>
#include <stdexcept>

#include "blkcom.hpp"
#include "time.hpp"

namespace emtp {

  // Classes.
  class storage_exceeded_error : public std::runtime_error
  {
  public:
    storage_exceeded_error () : std::runtime_error ("")
    {
    }

  public:
    const char *what (void) const noexcept
    {
      std::stringstream ss;
      //
      ss << std::string (5, ' ');
      ss << "Storage exceeded for list number ";
      ss << std::setw(2) << std::setfill('0') << blkcom::sLStat[ 15 ];
      ss << ".   See dimensioned limit in tabulation below.\n";
      ss << std::string(5, '-');
      ss << "The problem being inputted is simply too big for the program as currently dimensioned.   Since there usually are\n";
      ss << std::string(5, ' ');
      ss << "ways of circumventing this difficulty, it is suggested that the user consult his friendly neighborhood program\n";
      ss << std::string(5, ' ');
      ss << "maintenance man.\n";
      return ss.str().c_str();
    }
  };

  class time_error : public std::runtime_error
  {
  public:
    time_error () : std::runtime_error ("")
    {
    }

  public:
    const char *what (void) const noexcept
    {
      std::stringstream ss;
      //
      if (blkcom::nT >= 0.0) {
	ss << std::string (5, '-');
	ss << "Time-step size 'deltat' as read from columns 1-8 of the first miscellaneous data card is not positive.   The\n";
	ss << std::string (5, '-');
	ss << "user punched a value of ";
	ss << std::setw (14) << std::setprecision (4) << blkcom::sFLStat[ 15 ];
	ss << ".   Unlike Jules Verne, you are not allowed to stop or decrease time during\n";
	ss << std::string (5, '-');
	ss << "a simulation, my friend.   Don't try riding out of an active volcano on a raft floating on molten lava, either,\n";
	ss << std::string (5, '-');
	ss << "although that's another story.\n";
      } else {
	ss << std::string (5, '-');
	ss << "The starting time   't'   as read from the floating-point miscellaneous data card is negative, which is\n";
	ss << std::string (5, '-');
	ss << "illegal.   A value of";
	ss << std::setw (15) << std::setprecision (5) << blkcom::nT;
	ss << "   was read from the data field of columns 49-56.\n";
      }
      return ss.str ().c_str ();
    }
  };

  class branch_card_illegal_type_code_error : public std::runtime_error
  {
  public:
    branch_card_illegal_type_code_error () : std::runtime_error ("")
    {
    }

  public:
    const char *what (void) const noexcept
    {
      std::stringstream ss;
      //
      ss << std::string (5, '-');
      ss << "Illegal type code read from columns 1-2 of last branch card.   The user punched a value of ";
      ss << std::setw (2) << blkcom::sLStat[ 15 ];
      ss << ".   Either\n";
      ss << std::string (5, '-');
      ss << "the punched number itself is patently illegal (always an error, under any circumstances), or the card in question\n";
      ss << std::string (5, '-');
      ss << "his out of sequence in relation to the preceding data card which was inputted.   As an example of the latter\n";
      ss << std::string (5, '-');
      ss << "case, consider a '-3' punch, with the preceeding card not bearing a '-2' punch.   In any case, open up the user's\n";
      ss << std::string (5, ' ');
      ss << "manual, and reread the rules for the data type that you have been trying to input, my friend.\n";
      ss << std::string (5, ' ');
      ss << "Yet, in case this general advice does not seem to apply, consider the possible trouble which can arise from a\n";
      ss << std::string (5, ' ');
      ss << "preceding faulty use of the reference-branch capability. This feature has the EMTP looking for a certain number\n";
      ss << std::string (5, ' ');
      ss << "and type of branch cards, based on properties of the component to which reference has been made.   If the user's\n";
      ss << std::string (5, ' ');
      ss << "data cards do not in structure match those of the reference component, an error stop of the present type may very";
      ss << std::string (5, ' ');
      ss << "be expected.   Remember that in cases where two or more branches from reference bus  'bus3'  to reference bus\n";
      ss << std::string (5, ' ');
      ss << "'bus4'  (ordered pair of names, read from columns 15-24 as  2a6  information) exist, the EMTP will always pick\n";
      ss << std::string (5, ' ');
      ss << "the first one that it finds (in order of branch input) for reference purposes.\n";
      return ss.str ().c_str ();
    }
  };

  class last_branch_zero_impedance_error : public std::runtime_error
  {
  public:
    last_branch_zero_impedance_error () :std::runtime_error ("")
    {
    }

  public:
    const char *what (void) const noexcept
    {
      std::stringstream ss;
      //
      ss << std::string (5, ' ');
      ss << "Last branch was zero impedance (R, L, C fields of columns 27-44 were all zero).   If you really want a short\n";
      ss << std::string (5, ' ');
      ss << "circuit, you must punch a very small value for  R  or L.   Or better yet, why not do away with one of the node\n";
      ss << std::string (5, ' ');
      ss << "names of this branch, treating both ends as the same bus (a perfect short circuit).\n";
      return ss.str ().c_str ();
    }
  };

  class non_monotone_increasing_characteristic_error : public std::runtime_error
  {
  public:
    non_monotone_increasing_characteristic_error () : std::runtime_error ("")
    {
    }

  public:
    const char *what (void) const noexcept
    {
      std::stringstream ss;
      //
      ss << std::string (5, ' ');
      ss << "The user has been inputting pairs of points which define a nonlinear (or pseudo-nonlinear) element characteristic.\n";
      ss << std::string (5, ' ');
      ss << "These must be in order, moving ever to the right and upward in the x-y plane.   But the user's just-inputted\n";
      ss << std::string (5, ' ');
      ss << "characteristic is not monotone increasing as it should be.   A decrease in one of the two coordinate points\n";
      ss << std::string (5, ' ');
      ss << "has been detected on the last data card which was read.   Shape up or ship out, Jack.\n";
      return ss.str ().c_str ();
    }
  };

  class dummy_function_called_error : public std::runtime_error
  {
  public:
    dummy_function_called_error () : std::runtime_error ("")
    {
    }

  public:
    const char *what (void) const noexcept
    {
      std::stringstream ss;
      //
      ss << std::string (5, ' ');
      ss << "Dummy function is called, something wrong with this version of EMTP++.\n";
      return ss.str ().c_str ();
    }
  };

}

namespace over51 {

  // Prototypes.
  void subr51(void);
  void over51(void);

}

#endif // _OVER51_HPP