#pragma once

#include "gsl/gsl"
#include <vector>

#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;

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

	Tile(const Configuration& cfg, const MpiEnvironment& env)
	    : _cfg(cfg), _env(env) {
		const auto& gridSize = Size{cfg.GridColumns, cfg.GridRows};

		const auto& header = FileIO::ReadHeader(cfg.InputFilePath);
		const auto& headerLength = header.HeaderLength;
		const auto& _globalSize = header.GlobalSize;
		_tileSize = FileIO::GetTileSize(_globalSize, gridSize);

		_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::ReadTile(cfg.InputFilePath, headerLength, _globalSize, gridSize,
		                 _env.worldRank(), gsl::span<State>(_memoryA));
	}
};