// Copyright 2019 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef rr_Print_hpp
#define rr_Print_hpp

#if !defined(NDEBUG)
#define ENABLE_RR_PRINT 1 // Enables RR_PRINT(), RR_WATCH()
#endif // !defined(NDEBUG)

#ifdef ENABLE_RR_PRINT

#include "Reactor.hpp"

#include <string>
#include <vector>

namespace rr {

// PrintValue holds the printf format and value(s) for a single argument
// to Print(). A single argument can be expanded into multiple printf
// values - for example a Float4 will expand to "%f %f %f %f" and four
// scalar values.
// The PrintValue constructor accepts the following:
//   * Reactor LValues, RValues, Pointers.
//   * Standard Plain-Old-Value types (int, float, bool, etc)
//   * Custom types that specialize the PrintValue::Ty template struct.
//   * Static arrays in the form T[N] where T can be any of the above.
class PrintValue
{
	// Ty is a template that can be specialized for printing type T.
	// Each specialization must expose:
	//  * A 'static std::string fmt(const T& v)' method that provides the
	//    printf format specifier.
	//  * A 'static std::vector<rr::Value*> val(const T& v)' method that
	//    returns all the printf format values.
	template <typename T> struct Ty
	{
		// static std::string fmt(const T& v);
		// static std::vector<rr::Value*> val(const T& v);
	};

	// returns the printf values for all the values in the given array.
	template <typename T>
	static std::vector<Value*> val(const T* list, int count) {
		std::vector<Value*> values;
		values.reserve(count);
		for(int i = 0; i < count; i++)
		{
			auto v = val(list[i]);
			values.insert(values.end(), v.begin(), v.end());
		}
		return values;
	}

	// fmt returns the comma-delimited list of printf format strings for
	// every element in the provided list, all enclosed in square brackets.
	template <typename T>
	static std::string fmt(const T* list, int count)
	{
		std::string out = "[";
		for(int i = 0; i < count; i++)
		{
			if(i > 0) { out += ", "; }
			out += fmt(list[i]);
		}
		return out + "]";
	}

	static std::string addr(const void* ptr)
	{
		char buf[32];
		snprintf(buf, sizeof(buf), "%p", ptr);
		return buf;
	}

public:
	const std::string format;
	const std::vector<Value*> values;

	// Constructs a PrintValue for the given value.
	template <typename T>
	PrintValue(const T& v) : format(fmt(v)), values(val(v)) {}

	// Constructs a PrintValue for the given static array.
	template <typename T, int N>
	PrintValue(const T (&v)[N]) : format(fmt(&v[0], N)), values(val(&v[0], N)) {}

	// Constructs a PrintValue for the given array starting at arr of length
	// len.
	template <typename T>
	PrintValue(const T* arr, int len) : format(fmt(arr, len)), values(val(arr, len)) {}

	// PrintValue constructors for plain-old-data values.
	PrintValue(bool v) : format(v ? "true" : "false") {}
	PrintValue(int8_t v) : format(std::to_string(v)) {}
	PrintValue(uint8_t v) : format(std::to_string(v)) {}
	PrintValue(int16_t v) : format(std::to_string(v)) {}
	PrintValue(uint16_t v) : format(std::to_string(v)) {}
	PrintValue(int32_t v) : format(std::to_string(v)) {}
	PrintValue(uint32_t v) : format(std::to_string(v)) {}
	PrintValue(int64_t v) : format(std::to_string(v)) {}
	PrintValue(uint64_t v) : format(std::to_string(v)) {}
	PrintValue(float v) : format(std::to_string(v)) {}
	PrintValue(double v) : format(std::to_string(v)) {}

	template <typename T>
	PrintValue(const T* v) : format(addr(v)) {}

	// vals is a helper to build composite value lists.
	// vals returns the full, sequential list of printf argument values used
	// to print all the provided variadic values.
	// vals() is intended to be used by implementations of
	// PrintValue::Ty<>::vals() to help declare aggregate types.
	// For example, if you were declaring a PrintValue::Ty<> specialization
	// for a custom Mat4x4 matrix formed from four Vector4 values, you'd
	// write:
	//
	// namespace rr
	// {
	//		template <> struct PrintValue::Ty<Mat4x4>
	//		{
	//			static std::string fmt(const Mat4x4& v)
	//			{
	//				return	"[a: <%f, %f, %f, %f>,"
	//				        " b: <%f, %f, %f, %f>,"
	//				        " c: <%f, %f, %f, %f>,"
	//				        " d: <%f, %f, %f, %f>]";
	//			}
	//			static std::vector<rr::Value*> val(const Mat4x4& v)
	//			{
	//				return PrintValue::vals(v.a, v.b, v.c, v.d);
	//			}
	//		};
	//	}
	template<typename ... ARGS>
	static std::vector<Value*> vals(ARGS... v)
	{
		std::vector< std::vector<Value*> > lists = {val(v)...};
		std::vector<Value*> joined;
		for(const auto& list : lists)
		{
			joined.insert(joined.end(), list.begin(), list.end());
		}
		return joined;
	}

	// returns the printf format specifier for the given type via the
	// PrintValue::Ty<T> specialization.
	template <typename T>
	static std::string fmt(const T& v) { return Ty<T>::fmt(v); }

	// returns the printf value for the given type with a
	// PrintValue::Ty<T> specialization.
	template <typename T>
	static std::vector<Value*> val(const T& v) { return Ty<T>::val(v); }
};

// PrintValue::Ty<T> specializations for basic types.
template <> struct PrintValue::Ty<const char*>
{
	static std::string fmt(const char* v) { return "%s"; }
	static std::vector<Value*> val(const char* v);
};
template <> struct PrintValue::Ty<std::string>
{
	static std::string fmt(const std::string& v) { return PrintValue::Ty<const char*>::fmt(v.c_str()); }
	static std::vector<Value*> val(const std::string& v) { return PrintValue::Ty<const char*>::val(v.c_str()); }
};

// PrintValue::Ty<T> specializations for standard Reactor types.
template <> struct PrintValue::Ty<Bool>
{
	static std::string fmt(const RValue<Bool>& v) { return "%d"; }
	static std::vector<Value*> val(const RValue<Bool>& v) { return {v.value}; }
};
template <> struct PrintValue::Ty<Byte>
{
	static std::string fmt(const RValue<Byte>& v) { return "%d"; }
	static std::vector<Value*> val(const RValue<Byte>& v);
};
template <> struct PrintValue::Ty<Byte4>
{
	static std::string fmt(const RValue<Byte4>& v) { return "[%d, %d, %d, %d]"; }
	static std::vector<Value*> val(const RValue<Byte4>& v);
};
template <> struct PrintValue::Ty<Int>
{
	static std::string fmt(const RValue<Int>& v) { return "%d"; }
	static std::vector<Value*> val(const RValue<Int>& v);
};
template <> struct PrintValue::Ty<Int2>
{
	static std::string fmt(const RValue<Int>& v) { return "[%d, %d]"; }
	static std::vector<Value*> val(const RValue<Int2>& v);
};
template <> struct PrintValue::Ty<Int4>
{
	static std::string fmt(const RValue<Int4>& v) { return "[%d, %d, %d, %d]"; }
	static std::vector<Value*> val(const RValue<Int4>& v);
};
template <> struct PrintValue::Ty<UInt>
{
	static std::string fmt(const RValue<UInt>& v) { return "%u"; }
	static std::vector<Value*> val(const RValue<UInt>& v);
};
template <> struct PrintValue::Ty<UInt2>
{
	static std::string fmt(const RValue<UInt>& v) { return "[%u, %u]"; }
	static std::vector<Value*> val(const RValue<UInt2>& v);
};
template <> struct PrintValue::Ty<UInt4>
{
	static std::string fmt(const RValue<UInt4>& v) { return "[%u, %u, %u, %u]"; }
	static std::vector<Value*> val(const RValue<UInt4>& v);
};
template <> struct PrintValue::Ty<Short>
{
	static std::string fmt(const RValue<Short>& v) { return "%d"; }
	static std::vector<Value*> val(const RValue<Short>& v);
};
template <> struct PrintValue::Ty<Short4>
{
	static std::string fmt(const RValue<Short4>& v) { return "[%d, %d, %d, %d]"; }
	static std::vector<Value*> val(const RValue<Short4>& v);
};
template <> struct PrintValue::Ty<UShort>
{
	static std::string fmt(const RValue<UShort>& v) { return "%u"; }
	static std::vector<Value*> val(const RValue<UShort>& v);
};
template <> struct PrintValue::Ty<UShort4>
{
	static std::string fmt(const RValue<UShort4>& v) { return "[%u, %u, %u, %u]"; }
	static std::vector<Value*> val(const RValue<UShort4>& v);
};
template <> struct PrintValue::Ty<Float>
{
	static std::string fmt(const RValue<Float>& v) { return "[%f]"; }
	static std::vector<Value*> val(const RValue<Float>& v);
};
template <> struct PrintValue::Ty<Float4>
{
	static std::string fmt(const RValue<Float4>& v) { return "[%f, %f, %f, %f]"; }
	static std::vector<Value*> val(const RValue<Float4>& v);
};
template <> struct PrintValue::Ty<Long>
{
	static std::string fmt(const RValue<Long>& v) { return "%lld"; }
	static std::vector<Value*> val(const RValue<Long>& v) { return {v.value}; }
};
template <typename T> struct PrintValue::Ty< Pointer<T> >
{
	static std::string fmt(const RValue<Pointer<T>>& v) { return "%p"; }
	static std::vector<Value*> val(const RValue<Pointer<T>>& v) { return {v.value}; }
};
template <typename T> struct PrintValue::Ty< Reference<T> >
{
	static std::string fmt(const Reference<T>& v) { return PrintValue::Ty<T>::fmt(v); }
	static std::vector<Value*> val(const Reference<T>& v) { return PrintValue::Ty<T>::val(v); }
};
template <typename T> struct PrintValue::Ty< RValue<T> >
{
	static std::string fmt(const RValue<T>& v) { return PrintValue::Ty<T>::fmt(v); }
	static std::vector<Value*> val(const RValue<T>& v) { return PrintValue::Ty<T>::val(v); }
};

// Printv emits a call to printf() using the function, file and line,
// message and optional values.
// See Printv below.
void Printv(const char* function, const char* file, int line, const char* msg, std::initializer_list<PrintValue> vals);

// Printv emits a call to printf() using the provided message and optional
// values.
// Printf replaces any bracketed indices in the message with string
// representations of the corresponding value in vals.
// For example:
//   Printv("{0} and {1}", "red", "green");
// Would print the string:
//   "red and green"
// Arguments can be indexed in any order.
// Invalid indices are not substituted.
inline void Printv(const char* msg, std::initializer_list<PrintValue> vals)
{
	Printv(nullptr, nullptr, 0, msg, vals);
}

// Print is a wrapper over Printv that wraps the variadic arguments into an
// initializer_list before calling Printv.
template <typename ... ARGS>
void Print(const char* msg, const ARGS& ... vals) { Printv(msg, {vals...}); }

// Print is a wrapper over Printv that wraps the variadic arguments into an
// initializer_list before calling Printv.
template <typename ... ARGS>
void Print(const char* function, const char* file, int line, const char* msg, const ARGS& ... vals)
{
	Printv(function, file, line, msg, {vals...});
}

// RR_LOG is a macro that calls Print(), automatically populating the
// function, file and line parameters and appending a newline to the string.
//
// RR_LOG() is intended to be used for debugging JIT compiled code, and is
// not intended for production use.
#if defined(_WIN32)
	#define RR_LOG(msg, ...) Print(__FUNCSIG__, __FILE__, static_cast<int>(__LINE__), msg "\n", ##__VA_ARGS__)
#else
	#define RR_LOG(msg, ...) Print(__PRETTY_FUNCTION__, __FILE__, static_cast<int>(__LINE__), msg "\n", ##__VA_ARGS__)
#endif

// Macro magic to perform variadic dispatch.
// See: https://renenyffenegger.ch/notes/development/languages/C-C-plus-plus/preprocessor/macros/__VA_ARGS__/count-arguments
// Note, this doesn't attempt to use the ##__VA_ARGS__ trick to handle 0
#define RR_MSVC_EXPAND_BUG(X) X // Helper macro to force expanding __VA_ARGS__ to satisfy MSVC compiler.
#define RR_GET_NTH_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, N, ...) N
#define RR_COUNT_ARGUMENTS(...) RR_MSVC_EXPAND_BUG(RR_GET_NTH_ARG(__VA_ARGS__, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0))
static_assert(1 == RR_COUNT_ARGUMENTS(a), "RR_COUNT_ARGUMENTS broken"); // Sanity checks.
static_assert(2 == RR_COUNT_ARGUMENTS(a, b), "RR_COUNT_ARGUMENTS broken");
static_assert(3 == RR_COUNT_ARGUMENTS(a, b, c), "RR_COUNT_ARGUMENTS broken");

// RR_WATCH_FMT(...) resolves to a string literal that lists all the
// arguments by name. This string can be passed to LOG() to print each of
// the arguments with their name and value.
//
// RR_WATCH_FMT(...) uses the RR_COUNT_ARGUMENTS helper macro to delegate to a
// corresponding RR_WATCH_FMT_n specialization macro below.
#define RR_WATCH_CONCAT(a, b) a ## b
#define RR_WATCH_CONCAT2(a, b) RR_WATCH_CONCAT(a, b)
#define RR_WATCH_FMT(...) RR_MSVC_EXPAND_BUG(RR_WATCH_CONCAT2(RR_WATCH_FMT_, RR_COUNT_ARGUMENTS(__VA_ARGS__))(__VA_ARGS__))
#define RR_WATCH_FMT_1(_1) "\n  " #_1 ": {0}"
#define RR_WATCH_FMT_2(_1, _2)                                             RR_WATCH_FMT_1(_1) "\n  " #_2 ": {1}"
#define RR_WATCH_FMT_3(_1, _2, _3)                                         RR_WATCH_FMT_2(_1, _2) "\n  " #_3 ": {2}"
#define RR_WATCH_FMT_4(_1, _2, _3, _4)                                     RR_WATCH_FMT_3(_1, _2, _3) "\n  " #_4 ": {3}"
#define RR_WATCH_FMT_5(_1, _2, _3, _4, _5)                                 RR_WATCH_FMT_4(_1, _2, _3, _4) "\n  " #_5 ": {4}"
#define RR_WATCH_FMT_6(_1, _2, _3, _4, _5, _6)                             RR_WATCH_FMT_5(_1, _2, _3, _4, _5) "\n  " #_6 ": {5}"
#define RR_WATCH_FMT_7(_1, _2, _3, _4, _5, _6, _7)                         RR_WATCH_FMT_6(_1, _2, _3, _4, _5, _6) "\n  " #_7 ": {6}"
#define RR_WATCH_FMT_8(_1, _2, _3, _4, _5, _6, _7, _8)                     RR_WATCH_FMT_7(_1, _2, _3, _4, _5, _6, _7) "\n  " #_8 ": {7}"
#define RR_WATCH_FMT_9(_1, _2, _3, _4, _5, _6, _7, _8, _9)                 RR_WATCH_FMT_8(_1, _2, _3, _4, _5, _6, _7, _8) "\n  " #_9 ": {8}"
#define RR_WATCH_FMT_10(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)           RR_WATCH_FMT_9(_1, _2, _3, _4, _5, _6, _7, _8, _9) "\n  " #_10 ": {9}"
#define RR_WATCH_FMT_11(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11)      RR_WATCH_FMT_10(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10) "\n  " #_11 ": {10}"
#define RR_WATCH_FMT_12(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) RR_WATCH_FMT_11(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) "\n  " #_12 ": {11}"

// RR_WATCH() is a helper that prints the name and value of all the supplied
// arguments.
// For example, if you had the Int and bool variables 'foo' and 'bar' that
// you want to print, you can simply write:
//    RR_WATCH(foo, bar)
// When this JIT compiled code is executed, it will print the string
// "foo: 1, bar: true" to stdout.
//
// RR_WATCH() is intended to be used for debugging JIT compiled code, and
// is not intended for production use.
#define RR_WATCH(...) RR_LOG(RR_WATCH_FMT(__VA_ARGS__), __VA_ARGS__)

}  // namespace rr

#endif  // ENABLE_RR_PRINT

#endif  // rr_Print_hpp