#pragma once

#include <string>
#include <vector>

#include "gsl/gsl"

#include "Configuration.hpp"
#include "FileIO.hpp"
#include "MpiEnvironment.hpp"
#include "Util.hpp"
#include "state.hpp"

class Tile {
	const MpiEnvironment& _env;
	const Configuration& _cfg;

	std::vector<State> _memoryA;
	std::vector<State> _memoryB;
	gsl::multi_span<State, -1, -1> _model;
	gsl::multi_span<State, -1, -1> _nextModel;
	Size _tileSize;

	Tile(const Configuration& cfg, const MpiEnvironment& env)
	    : _cfg(cfg), _env(env) {
		const auto& header = FileIO::ReadHeader(cfg.InputFilePath);
		const auto& headerLength = header.HeaderLength;
		const auto& _globalSize = header.GlobalSize;
		_tileSize = FileIO::GetTileSize(_globalSize, cfg.Grid);

		_memoryA.resize((_tileSize.Cols + 2) * (_tileSize.Rows + 2));
		_memoryB.resize((_tileSize.Cols + 2) * (_tileSize.Rows + 2));
		_model =
		    gsl::as_multi_span(_memoryA.data(), gsl::dim(_tileSize.Rows + 2),
		                       gsl::dim(_tileSize.Cols + 2));
		_nextModel =
		    gsl::as_multi_span(_memoryB.data(), gsl::dim(_tileSize.Rows + 2),
		                       gsl::dim(_tileSize.Cols + 2));

		FileIO::ReadTileData(cfg.InputFilePath, headerLength, _globalSize, cfg.Grid,
		                 _env.worldRank(), gsl::span<State>(_memoryA));
	}

  public:
	auto& model() { return _model; }
	auto& model() const { return _model; }
	auto& nextModel() { return _nextModel; }
	auto tileSize() const { return _tileSize; }

	static auto Read(const Configuration& cfg, const MpiEnvironment& env) {
		return Tile{cfg, env};
	}
};

std::ostream& operator<<(std::ostream& out, const Tile& t) {
	auto hline = [](auto& out, auto length) {
		out << '+';
		std::fill_n(std::ostream_iterator<char>(out), length, '-');
		out << "+\n";
	};
	hline(out, t.tileSize().Cols);
	for (std::size_t x{1}; x <= t.tileSize().Rows; ++x) {
		out << '|';
		for (std::size_t y{1}; y <= t.tileSize().Cols; ++y) {
			out << to_integral(t.model()[x][y]);
		}
		out << "|\n";
	}
	hline(out, t.tileSize().Cols);
	return out;
}