/*
 * Copyright (C) 2017-2020  The Project X-Ray Authors.
 *
 * Use of this source code is governed by a ISC-style
 * license that can be found in the LICENSE file or at
 * https://opensource.org/licenses/ISC
 *
 * SPDX-License-Identifier: ISC
 */
#include <stdint.h>
#include <stdio.h>
#include <string.h>

#include <iostream>
#include <set>
#include <string>
#include <vector>

#include <absl/strings/numbers.h>
#include <absl/strings/str_cat.h>
#include <absl/strings/str_split.h>
#include <gflags/gflags.h>
#include <prjxray/memory_mapped_file.h>
#include <prjxray/xilinx/architectures.h>
#include <prjxray/xilinx/bitstream_reader.h>
#include <prjxray/xilinx/configuration.h>

DEFINE_bool(c, false, "output '*' for repeating patterns");
DEFINE_bool(C, false, "do not ignore the checksum in each frame");
DEFINE_int32(f,
             -1,
             "only dump the specified frame (might be used more than once)");
DEFINE_string(F,
              "",
              "<first_frame_address>:<last_frame_address> only dump frame in "
              "the specified range");
DEFINE_string(o, "", "write machine-readable output file with config frames");
DEFINE_bool(p, false, "output a binary netpgm image");
DEFINE_bool(x,
            false,
            "use format 'bit_%%08x_%%03d_%%02d_t%%d_h%%d_r%%d_c%%d_m%%d'\n"
            "The fields have the following meaning:\n"
            "  - complete 32 bit hex frame id\n"
            "  - word index with that frame (decimal)\n"
            "  - bit index with that word (decimal)\n"
            "  - decoded frame type from frame id\n"
            "  - decoded top/botttom from frame id (top=0)\n"
            "  - decoded row address from frame id\n"
            "  - decoded column address from frame id\n"
            "  - decoded minor address from frame id\n");
DEFINE_bool(y, false, "use format 'bit_%%08x_%%03d_%%02d'");
DEFINE_bool(z, false, "skip zero frames (frames with all bits cleared) in o");
DEFINE_string(part_file, "", "YAML file describing a Xilinx part");
DEFINE_string(architecture,
              "Series7",
              "Architecture of the provided bitstream");

namespace xilinx = prjxray::xilinx;

std::set<uint32_t> frames;
uint32_t frame_range_begin = 0, frame_range_end = 0;

std::vector<uint32_t> zero_frame(101);

struct BitReader {
	BitReader(const std::vector<uint8_t>& bytes) : bytes_(bytes) {}

	const std::vector<uint8_t>& bytes_;

	template <typename T>
	int operator()(T& arg) {
		using ArchType = std::decay_t<decltype(arg)>;
		auto reader =
		    xilinx::BitstreamReader<ArchType>::InitWithBytes(bytes_);
		if (!reader) {
			std::cerr << "Input doesn't look like a bitstream"
			          << std::endl;
			return 1;
		}

		std::cout << "Config size: " << reader->words().size()
		          << " words" << std::endl;

		auto part = ArchType::Part::FromFile(FLAGS_part_file);
		if (!part) {
			std::cerr << "Part file not found or invalid"
			          << std::endl;
			return 1;
		}
		auto config = xilinx::Configuration<ArchType>::InitWithPackets(
		    *part, *reader);
		if (!config) {
			std::cerr
			    << "Bitstream does not appear to be for this part"
			    << std::endl;
			return 1;
		}

		std::cout << "Number of configuration frames: "
		          << config->frames().size() << std::endl;

		FILE* f = stdout;

		if (!FLAGS_o.empty()) {
			f = fopen(FLAGS_o.c_str(), "w");

			if (f == nullptr) {
				printf(
				    "Can't open output file '%s' for "
				    "writing!\n",
				    FLAGS_o.c_str());
				return 1;
			}
		} else {
			fprintf(f, "\n");
		}

		std::vector<std::vector<bool>> pgmdata;
		std::vector<int> pgmsep;

		int word_length = sizeof(typename ArchType::WordType) * 8;
		for (auto& it : config->frames()) {
			if (FLAGS_z && it.second == zero_frame)
				continue;

			if (!frames.empty() && !frames.count(it.first))
				continue;

			if (frame_range_begin != frame_range_end &&
			    (it.first < frame_range_begin ||
			     frame_range_end <= it.first))
				continue;

			if (FLAGS_o.empty())
				printf(
				    "Frame 0x%08x (Type=%d Top=%d Row=%d "
				    "Column=%d "
				    "Minor=%d):\n",
				    static_cast<uint32_t>(it.first),
				    static_cast<unsigned int>(
				        it.first.block_type()),
				    it.first.is_bottom_half_rows() ? 1 : 0,
				    it.first.row(), it.first.column(),
				    it.first.minor());

			if (FLAGS_p) {
				if (it.first.minor() == 0 && !pgmdata.empty())
					pgmsep.push_back(pgmdata.size());

				pgmdata.push_back(std::vector<bool>());

				for (size_t i = 0; i < it.second.size(); i++)
					for (int k = 0; k < word_length; k++)
						pgmdata.back().push_back(
						    (it.second.at(i) &
						     (1 << k)) != 0);
			} else if (FLAGS_x || FLAGS_y) {
				for (int i = 0; i < (int)it.second.size();
				     i++) {
					for (int k = 0; k < word_length; k++) {
						if (((i != 50 || k > 12 ||
						      FLAGS_C) ||
						     std::is_same<
						         ArchType,
						         prjxray::xilinx::
						             Spartan6>::
						         value) &&
						    ((it.second.at(i) &
						      (1 << k)) != 0)) {
							if (FLAGS_x)
								fprintf(
								    f,
								    "bit_%08x_%"
								    "03d_%"
								    "02d_t%d_h%"
								    "d_r%d_c%"
								    "d_m%d\n",
								    static_cast<
								        uint32_t>(
								        it.first),
								    i, k,
								    static_cast<
								        unsigned int>(
								        it.first
								            .block_type()),
								    it.first.is_bottom_half_rows()
								        ? 1
								        : 0,
								    it.first
								        .row(),
								    it.first
								        .column(),
								    it.first
								        .minor());
							else
								fprintf(
								    f,
								    "bit_%08x_%"
								    "03d_"
								    "%02d\n",
								    static_cast<
								        uint32_t>(
								        it.first),
								    i, k);
						}
					}
				}
				if (FLAGS_o.empty())
					fprintf(f, "\n");
			} else {
				if (!FLAGS_o.empty())
					fprintf(
					    f, ".frame 0x%08x\n",
					    static_cast<uint32_t>(it.first));

				for (size_t i = 0; i < it.second.size(); i++)
					if (std::is_same<ArchType,
					                 prjxray::xilinx::
					                     Spartan6>::value) {
						fprintf(
						    f, "%08x%s",
						    it.second.at(i) &
						        0xffffffff,
						    (i % 6) == 5 ? "\n" : " ");
					} else {
						fprintf(
						    f, "%08x%s",
						    it.second.at(i) &
						        ((i != 50 || FLAGS_C)
						             ? 0xffffffff
						             : 0xffffe000),
						    (i % 6) == 5 ? "\n" : " ");
					}

				fprintf(f, "\n\n");
			}
		}

		if (FLAGS_p) {
			int width = pgmdata.size() + pgmsep.size();
			int height = ArchType::words_per_frame * word_length;
			fprintf(f, "P5 %d %d 15\n", width, height);

			for (int y = 0,
			         bit = ArchType::words_per_frame * word_length -
			               1;
			     y < height; y++, bit--) {
				for (int x = 0, frame = 0, sep = 0; x < width;
				     x++, frame++) {
					if (sep < int(pgmsep.size()) &&
					    frame == pgmsep.at(sep)) {
						fputc(8, f);
						x++, sep++;
					}

					if (bit >=
					    (int)pgmdata.at(frame).size()) {
						fputc(0, f);
						continue;
					}

					fputc(
					    pgmdata.at(frame).at(bit) ? 15 : 0,
					    f);
				}

				if (bit % word_length == 0 && y) {
					for (int x = 0; x < width; x++)
						fputc(8, f);
					y++;
				}
			}
		}

		if (!FLAGS_o.empty())
			fclose(f);

		printf("DONE\n");
		return 0;
	}
};

int main(int argc, char** argv) {
	gflags::SetUsageMessage(
	    absl::StrCat("Usage: ", argv[0], " [options] [bitfile]"));
	gflags::ParseCommandLineFlags(&argc, &argv, true);

	if (FLAGS_f >= 0) {
		frames.insert(FLAGS_f);
	}

	if (!FLAGS_F.empty()) {
		std::pair<std::string, std::string> p =
		    absl::StrSplit(FLAGS_F, ":");
		frame_range_begin = strtol(p.first.c_str(), nullptr, 0);
		frame_range_end = strtol(p.second.c_str(), nullptr, 0) + 1;
	}

	std::vector<uint8_t> in_bytes;
	if (argc == 2) {
		auto in_file_name = argv[1];
		auto in_file =
		    prjxray::MemoryMappedFile::InitWithFile(in_file_name);
		if (!in_file) {
			std::cerr << "Can't open input file '" << in_file_name
			          << "' for reading!" << std::endl;
			return 1;
		}

		std::cout << "Bitstream size: " << in_file->size() << " bytes"
		          << std::endl;

		in_bytes = std::vector<uint8_t>(
		    static_cast<uint8_t*>(in_file->data()),
		    static_cast<uint8_t*>(in_file->data()) + in_file->size());
	} else {
		while (1) {
			int c = getchar();
			if (c == EOF)
				break;
			in_bytes.push_back(c);
		}

		std::cout << "Bitstream size: " << in_bytes.size() << " bytes"
		          << std::endl;
	}

	xilinx::Architecture::Container arch_container =
	    xilinx::ArchitectureFactory::create_architecture(
	        FLAGS_architecture);
	return absl::visit(BitReader(in_bytes), arch_container);
}