// License: Modified MIT (NON-AI)
// See the LICENSE file in the root directory for license information.
// Copyright 2025 Timothy Prepscius

#pragma once

#include "../type_traits/is_iterable.hpp"
#include <sstream>
#include <string>
#include "demangle.h"

#include "../types/Types+IO.h"

namespace tjp::core {

template<typename T>
struct LogOf
{
	const T &t;
	explicit LogOf(const T &t_) : t(t_) {}
	
	std::ostream &operator()(std::ostream &o) const
	{
		return o << t;
	}
} ;

template<typename T>
struct LogOfV
{
	T t;
	explicit LogOfV(T t_) : t(t_) {}
	
	std::ostream &operator()(std::ostream &o) const
	{
		return o << t;
	}
} ;

template<typename T>
auto logOfV(T t) { return LogOfV<T>(t); }

template<typename T>
std::ostream &operator <<(std::ostream &o, const LogOf<T> &v)
{
	return v(o);
}

template<typename T>
std::ostream &operator <<(std::ostream &o, const LogOfV<T> &v)
{
	return v(o);
}

template<typename T, typename std::enable_if<!is_iterable<T>::value, T>::type* = nullptr>
auto logOf(const T &t);

template<typename T, typename std::enable_if<is_iterable<T>::value, T>::type* = nullptr>
auto logOf(const T &t);


inline
auto logOf(const std::string &t) { return t; }

inline
auto logOf(bool v) { return v ? "true" : "false"; }

template<typename A, typename B>
auto logOf(const std::pair<A,B> &t) {
	std::ostringstream o;
	o << "(" << logOf(t.first) << "," << logOf(t.second) << ")";
	return o.str();
}

template<typename T, typename std::enable_if<!is_iterable<T>::value, T>::type*>
auto logOf(const T &t) { return LogOf<T>(t); }

template<typename T, typename std::enable_if<is_iterable<T>::value, T>::type*>
auto logOf(const T &t) {
	std::ostringstream o;
	o << "[";
	auto first = true;
	for (auto v : t)
	{
		if (!first)
		{
			o << ",";
		}
		
		o << logOf(v);
		first = false;
	}
	o << "]";
	
	return o.str();
}

inline
auto logOf(const std::string_view &v)
{
	return v;
}

template<typename T>
struct NullOrValue
{
	const T *t;
	explicit NullOrValue(const T *t_) : t(t_) {}
} ;

template<typename T>
std::ostream &operator <<(std::ostream &o, const NullOrValue<T> &v)
{
	if (v.t)
		return o << logOf(*v.t);
		
	return o << "null";
}

template<typename T>
auto logOfRef(T *t)
{
	return NullOrValue<T>(t);
}

template<typename T>
struct NullOrPtrValue
{
	const T *t;
	explicit NullOrPtrValue(const T *t_) : t(t_) {}
} ;

template<typename T>
std::ostream &operator <<(std::ostream &o, const NullOrPtrValue<T> &v)
{
	if (v.t)
		return o << "[" << v.t << "] " << logOf(*v.t);
		
	return o << "null";
}

template<typename T>
auto logPtrValue(T *t)
{
	return NullOrPtrValue<T>(t);
}

template<typename T>
auto logPtr(T *t)
{
	return t;
}

template<typename T>
struct SpaceBefore
{
	const T &t;
} ;

template<typename T>
std::ostream &operator <<(std::ostream &o, const SpaceBefore<T> &v)
{
	return o << " " << logOf(v.t);
}

template<typename T>
SpaceBefore<T> _logOf(const T &t)
{
	return SpaceBefore<T> { t };
}

template<typename T>
auto logOfDispatch(T &&t)
{
	return logOf(std::forward<T>(t));
}

template<typename T>
auto logOfDispatchV(T t)
{
	return logOfV(t);
}

#define logOfThis(x) "[" << tjp::core::logPtr(x) << "] "
#define logVar(x) #x << " " << tjp::core::logOfDispatch(x) << " "
#define logVarV(x) #x << " " << tjp::core::logOfDispatchV(x) << " "
#define logType(x) #x << " " << tjp::core::type_id<x>().name() << " "
#define logLabel(l) l << " "
#define logLabelVar(l, x) l << " " << tjp::core::logOfDispatch(x) << " "
#define logLabelVarV(l, x) l << " " << tjp::core::logOfDispatchV(x) << " "

} // namespace