// Code derived from Stroustrup's PPP2 book
// § 10.11.2 Reading structured values (v2)
//  -and beginning on p 370

// note: this is a reworked version of the book's original for this section. the
// primary modification being to use token parsing (similar to chs 6&7) instead
// for retrieving the data from the readings file. one advantage of this new
// design is that overall memory consumption is lower than with the original.

#include <algorithm>
#include <cctype>
#include <fstream>
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>

using namespace std;

void error(string const& s) { throw runtime_error(s); }
void error(string const& s1, string const& s2) { error(s1 + s2); }
void error(string const& s, int const i)
{
  ostringstream os;
  os << s << ": " << i;
  error(os.str());
}

//------------------------------------------------------------------------------
/** run-time checked narrowing cast (type conversion)
 *
 * @param[in] a object to be typecast
 * @return copy of `a`, of the type `R` specified for the cast
 * @note throws `std::runtime_error` on information loss
 */
template <class R, class A>
R narrow_cast(A const& a)
{
  R r = R(a);
  if (A(r) != a)
    error("narrow_cast() info loss");

  return r;
}

//------------------------------------------------------------------------------

constexpr char number{'8'};  // t.kind==number means that t is a number Token
constexpr char name{'a'};    // name token (eg. dec, year, jan, month, etc.)

//------------------------------------------------------------------------------
class Token {
 public:
  explicit Token(char const ch) : kind{ch} {}

  Token(char const ch, double const val) : kind{ch}, value{val} {}

  Token(char const ch, string const& n) : kind{ch}, name{n} {}

  char   kind  = '0';
  double value = 0.0;
  string name;
};

//------------------------------------------------------------------------------
class Token_stream {
 public:
  Token_stream();

  Token get(ifstream& ist);
  void  putback(Token const& t);

 private:
  bool  full = false;
  Token buffer;
};

//------------------------------------------------------------------------------
Token_stream::Token_stream() : full{false}, buffer{0} {}

//------------------------------------------------------------------------------
// read a token from input stream
Token Token_stream::get(ifstream& ist)
{
  if (full) {  // check if we already have a Token ready
    full = false;
    return buffer;
  }

  char ch;
  ist >> ch;

  if (ist.eof())
    return Token{'E'};

  // clang-format off
  switch (ch) {
    case '{':
    case '}':
    case '(':
    case ')':
      return Token{ch};
      break;
    case '.': case '-':
    case '0': case '1': case '2': case '3': case '4':
    case '5': case '6': case '7': case '8': case '9': {
      ist.putback(ch);  // put digit back into the input stream
      double val;
      ist >> val;

      return Token{number, val};
      break;
    }
    default:
      if (isalpha(ch)) {
        string s;
        s += ch;
        while (ist.get(ch) && isalpha(ch))
          s += ch;

        ist.putback(ch);

        return Token{name, s};
      }
      error("Bad token");
      return Token{'K'};  // invalid, shouldn't reach here
  }
  // clang-format on
}

//------------------------------------------------------------------------------
// put token back into stream
void Token_stream::putback(Token const& t)
{
  if (full)
    error("putback() into a full buffer");

  buffer = t;
  full   = true;
}

//------------------------------------------------------------------------------

Token_stream ts;

//------------------------------------------------------------------------------

const vector<string> month_input_tbl{"jan", "feb", "mar", "apr", "may", "jun",
                                     "jul", "aug", "sep", "oct", "nov", "dec"};

// is s the name of a month? If so return its index [0:11] otherwise –1
int month_to_int(string const& s)
{
  for (int i = 0; i < 12; ++i)
    if (month_input_tbl[i] == s)
      return i;

  return -1;
}

const vector<string> month_print_tbl{
    "January", "February", "March",     "April",   "May",      "June",
    "July",    "August",   "September", "October", "November", "December"};

// months [0:11]
string int_to_month(int const i)
{
  if (i < 0 || 12 <= i)
    error("bad month index");

  return month_print_tbl[i];
}

//------------------------------------------------------------------------------

struct Reading {
  int    day;
  int    hour;
  double temperature;
};

// a rough test
bool is_valid(Reading const& r)
{
  constexpr int implausible_min{-200};
  constexpr int implausible_max{200};

  if (r.day < 1 || 31 < r.day)  // naive
    return false;

  if (r.hour < 0 || 23 < r.hour)
    return false;

  if (r.temperature < implausible_min || implausible_max < r.temperature)
    return false;

  return true;
}

//------------------------------------------------------------------------------

constexpr int nada{-1};

struct Month {
  explicit Month(int const m) : month{m} {}

  int             month{nada};  // [0:11] January is 0
  vector<Reading> rdgs;         // Reading's contain their own day/hour info
};

struct Year {
  explicit Year(int const y) : year{y} {}

  int           year{nada};  // positive == A.D.
  vector<Month> months;
};

//------------------------------------------------------------------------------
void readings(ifstream& ist, vector<Reading>& rdgs)
{
  Token t = ts.get(ist);

  while (true) {
    switch (t.kind) {
      case '(': {
        double day, hr, temp;

        t = ts.get(ist);
        if (t.kind != number)
          error("day expected in readings()");

        day = t.value;

        t = ts.get(ist);
        if (t.kind != number)
          error("hour expected in readings()");

        hr = t.value;

        t = ts.get(ist);
        if (t.kind != number)
          error("temp expected in readings()");

        temp = t.value;

        t = ts.get(ist);
        if (t.kind != ')')
          error("')' expected in readings()");

        // get a clean r each time around
        Reading const r{narrow_cast<int>(day), narrow_cast<int>(hr), temp};
        //
        // note: code could be written to allow invalid or duplicate readings to
        // be accounted for during this function (or in months()) if so desired.
        //
        // otherwise, invalid readings are simply ignored here, and are not
        // written out to the month's readings container (while duplicates are).
        //
        if (is_valid(r))
          rdgs.push_back(r);

        break;
      }
      default: ts.putback(t); return;
    }

    t = ts.get(ist);
  }
}

//------------------------------------------------------------------------------
void months(ifstream& ist, vector<Month>& mns)
{
  Token t = ts.get(ist);

  while (true) {
    switch (t.kind) {
      case '{': {
        t = ts.get(ist);
        if (t.kind != name)
          error("month_lbl expected");

        t = ts.get(ist);
        if (t.kind != name)
          error("month_name expected");

        string const month_nm = t.name;

        // get all readings, for this month:
        vector<Reading> rdgs;  //
        readings(ist, rdgs);   //

        t = ts.get(ist);
        if (t.kind != '}')
          error("'}' expected in months()");

        // get a clean m each time around
        Month m{month_to_int(month_nm)};
        m.rdgs = rdgs;
        mns.push_back(m);
        break;
      }
      default: ts.putback(t); return;
    }

    t = ts.get(ist);
  }
}

//------------------------------------------------------------------------------
void years(ifstream& ist, vector<Year>& ys)
{
  Token t = ts.get(ist);

  while (true) {
    switch (t.kind) {
      case '{': {
        t = ts.get(ist);
        if (t.kind != name)
          error("year_lbl expected");

        t = ts.get(ist);
        if (t.kind != number)
          error("year_num expected");

        double const yr = t.value;

        // get all months with readings, for this year:
        vector<Month> mns;  //
        months(ist, mns);   //

        t = ts.get(ist);
        if (t.kind != '}')
          error("'}' expected in years()");

        // get a clean y each time around
        Year y{narrow_cast<int>(yr)};
        y.months = mns;
        ys.push_back(y);
        break;
      }
      case 'E':
        return;  // all data is parsed (eof)
        break;
      default: ist.clear(ios_base::failbit); error("unknown error in years()");
    }

    t = ts.get(ist);
  }
}

//------------------------------------------------------------------------------
void print_year(ostream& ost, Year const& y)
{
  ost << "\nYEAR:  " << y.year << '\n';

  for (auto const& m : y.months) {
    ost << "  MONTH:  " << int_to_month(m.month) << '\n';

    auto rdgs_sort = m.rdgs;  // we'll use a sortable copy of month's readings

    // 1st pass, sorted by-hour
    sort(begin(rdgs_sort), end(rdgs_sort),
         // note: this is a lambda expression (§15.3.3)
         [](Reading const& a, Reading const& b) { return (a.hour < b.hour); });
    // 2nd pass, sorted by-day
    sort(begin(rdgs_sort), end(rdgs_sort),
         [](Reading const& a, Reading const& b) { return (a.day < b.day); });

    for (auto const& r : rdgs_sort) {
      ost << "    (" << r.day       //
          << ", " << r.hour         //
          << ", " << r.temperature  //
          << ")\n";
    }
  }
}

//------------------------------------------------------------------------------
int main()
try {
  // open an input file:
  cout << "Please enter input file name (eg, odd_format.txt ):  ";
  string iname;
  cin >> iname;
  ifstream ist{iname};
  if (! ist)
    error("can't open input file ", iname);

  ist.exceptions(ist.exceptions() | ios_base::badbit);  // throw for bad()

  // open an output file:
  cout << "Please enter output file name:  ";
  string oname;
  cin >> oname;

  if (oname == iname)
    error("this would overwrite the original file");

  ofstream ost{oname};
  if (! ost)
    error("can't open output file ", oname);

  // read an arbitrary number of years from input stream:
  vector<Year> ys;  //
  years(ist, ys);   //

  // write formatted data to output stream:
  cout << "read " << ys.size() << " years of readings\n";
  for (auto const& y : ys)
    print_year(ost, y);

} catch (exception const& e) {
  cerr << "error: " << e.what() << '\n';
  return 1;

} catch (...) {
  cerr << "Oops: unknown exception!\n";
  return 2;
}