#include "io.hpp"
#include <algorithm>
#include <boost/tokenizer.hpp>
#include <exception>
#include <fstream>
#include <regex>
#include <string>
#include <unordered_map>
#include "compression.hpp"

using namespace std;
using Int = STD::Int;
using Float = STD::Float;
using Matrix = STD::Matrix;

Matrix read_matrix(istream &is, const string &separator) {
  // TODO improve / factor / simplify implementation
  vector<string> row_names, col_names;
  Matrix m = read_floats(is, separator, row_names, col_names);
  return m;
}

Matrix vec_of_vec_to_multi_array_float(const vector<vector<Float>> &v) {
  const size_t s1 = v.size();
  const size_t s2 = v[0].size();
  Matrix A(s1, s2);
  for (size_t i = 0; i < s1; ++i)
    for (size_t j = 0; j < s2; ++j)
      A(i, j) = v[i][j];
  return A;
}

Matrix read_floats(istream &ifs, const string &separator,
                   vector<string> &row_names, vector<string> &col_names) {
  using tokenizer = boost::tokenizer<boost::char_separator<char>>;
  boost::char_separator<char> sep(separator.c_str());
  vector<vector<Float>> m;

  string line;

  getline(ifs, line);
  tokenizer tok(line, sep);
  for (auto token : tok)
    col_names.push_back(token.c_str());

  while (getline(ifs, line)) {
    tok = tokenizer(line, sep);
    size_t col = 0;
    vector<Float> v;
    for (auto token : tok)
      if (col++ == 0)
        row_names.push_back(token);
      else
        v.push_back(atof(token.c_str()));
    m.push_back(v);
  }

  auto matrix = vec_of_vec_to_multi_array_float(m);

  size_t ncol = matrix.cols();

  if (ncol == col_names.size())
    return matrix;
  else if (ncol == col_names.size() - 1) {
    vector<string> new_col_names(begin(col_names) + 1, end(col_names));
    col_names = new_col_names;
    return matrix;
  } else
    throw std::runtime_error(
        string()
        + "Mismatch between number of columns and number of column labels.\n"
        + "There are " + std::to_string(ncol) + " columns and "
        + std::to_string(col_names.size()) + " column names.");
}

void print_matrix_head(ostream &os, const Matrix &m, const std::string &label,
                       size_t n) {
  if (label != "")
    os << label << std::endl;
  size_t X = m.rows();
  size_t Y = m.cols();
  for (size_t x = 0; x < std::min<size_t>(X, n); ++x) {
    for (size_t y = 0; y < Y; ++y)
      os << (y > 0 ? "\t" : "") << m(x, y);
    os << std::endl;
  }

  if (label != "")
    os << label << " ";
  os << "column sums" << std::endl;

  size_t zeros = 0;
  for (size_t y = 0; y < Y; ++y) {
    double sum = 0;
    for (size_t x = 0; x < X; ++x) {
      if (m(x, y) == 0)
        zeros++;
      sum += m(x, y);
    }
    os << (y > 0 ? "\t" : "") << sum;
  }
  os << std::endl;

  os << "There are " << zeros << " zeros";
  if (label != "")
    os << " in " << label;
  os << ". This corresponds to " << (100.0 * zeros / X / Y) << "%."
     << std::endl;
}