#include <fstream>
#include <iomanip>
#include <iostream>

#include <prjxray/xilinx/xc7series/frame_address.h>

namespace xc7series = prjxray::xilinx::xc7series;

void xc7_frame_address_decode(std::istream* input_stream) {
	for (uint32_t frame_address_raw;
	     (*input_stream) >> std::setbase(0) >> frame_address_raw;) {
		xc7series::FrameAddress frame_address(frame_address_raw);
		std::cout << "[" << std::hex << std::showbase << std::setw(10)
		          << frame_address_raw << "] "
		          << (frame_address.is_bottom_half_rows() ? "BOTTOM"
		                                                  : "TOP")
		          << " Row=" << std::setw(2) << std::dec
		          << static_cast<unsigned int>(frame_address.row())
		          << " Column=" << std::setw(2) << std::dec
		          << frame_address.column() << " Minor=" << std::setw(2)
		          << std::dec
		          << static_cast<unsigned int>(frame_address.minor())
		          << " Type=" << frame_address.block_type()
		          << std::endl;
	}
}

int main(int argc, char* argv[]) {
	if (argc > 1) {
		std::ifstream file_stream(argv[1]);
		if (file_stream) {
			xc7_frame_address_decode(&file_stream);
			return 0;
		}
	}

	xc7_frame_address_decode(&std::cin);

	return 0;
}
