// -*- c++ -*-
// Distributed under the BSD 2-Clause License.
// See accompanying file LICENSE for details.
#include "task_fn.h"

#include <iostream>
#include <fstream>
#include <cassert>

#include "ctor.h"
#include "execute.h"
#include "util.h"

TaskFn::TaskFn(const ctor::build_configuration& config_, const ctor::settings& settings_,
               const std::string& sourceDir_, const ctor::source& source)
	: Task(config_, settings_, sourceDir_)
	, sourceFile(sourceDir_)
	, config(config_)
	, settings(settings_)
{
	sourceFile /= source.file;

	for(const auto& src : config.sources)
	{
		auto _src = sourceFile / src.file;
		sources.push_back(_src.string());
	}

	std::filesystem::create_directories(std::filesystem::path(settings.builddir) / sourceFile.parent_path());

	target_type = config.type;
	source_language = source.language;

	if(source.output.empty())
	{
		std::filesystem::path base = sourceFile.parent_path();
		_targetFile =
			//std::filesystem::path(settings.builddir) /
			base / config.target;
	}
	else
	{
		_targetFile = source.output;
	}

	sourceListFile = targetFile().parent_path() / targetFile().filename();
	sourceListFile += ".sources";
}

bool TaskFn::dirtyInner()
{
	if(!std::filesystem::exists(targetFile()))
	{
		//std::cout << "Missing targetFile\n";
		return true;
	}

	if(!std::filesystem::exists(sourceListFile))
	{
		//std::cout << "Missing sourceListFile\n";
		return true;
	}

	{
		auto lastSourceList = readFile(sourceListFile.string());
		if(sourceListString() != lastSourceList)
		{
			//std::cout << "The compiler sourceList changed\n";
			return true;
		}
	}

	std::filesystem::file_time_type last_changed{};
	bool missing{false};
	const auto visitor = overloaded
		{
			[](std::monostate) {},
			[&](ctor::GeneratorCb)
			{
				if(!std::filesystem::exists(sourceFile))
				{
					missing = true;
				}
				last_changed = std::filesystem::last_write_time(sourceFile);
			},
			[&](ctor::GeneratorCb2)
			{
				bool first{true};
				for(const auto& source : sources)
				{
					if(!std::filesystem::exists(source))
					{
						missing |= true;
					}
					else
					{
						if(first)
						{
							last_changed = std::filesystem::last_write_time(source);
						}
						else
						{
							last_changed =
								std::max(last_changed,
								         std::filesystem::last_write_time(source));
						}
					}
					first = false;
				}
			},
		};
	std::visit(visitor, config.function);

	if(missing)
	{
		return true;
	}

	if(last_changed > std::filesystem::last_write_time(targetFile()))
	{
		//std::cout << "The targetFile older than sourceFile\n";
		return true;
	}

	return false;
}

int TaskFn::runInner()
{
//	if(!std::filesystem::exists(sourceFile))
//	{
//		std::cout << "Missing source file: " << sourceFile.string() << "\n";
//		return 1;
//	}

	{ // Write sourceList to file.
		std::ofstream sourceListStream(sourceListFile.string());
		std::cout << "Write to sources file: " << sourceListFile.string() << '\n';
		sourceListStream << sourceListString();
		std::cout << "Content: " << sourceListString() << '\n';
	}

	if(settings.verbose >= 0)
	{
		std::string output = "Fn " +
			sourceFile.lexically_normal().string() + " => " +
			targetFile().lexically_normal().string() + '\n';
		std::cout << output << std::flush;
	}

	int res{};
	const auto visitor = overloaded
		{
			[](std::monostate) {},
			[&](ctor::GeneratorCb cb)
			{
				res = cb(sourceFile.string(),
				         targetFile().string(),
				         config,
				         settings);
			},
			[&](ctor::GeneratorCb2 cb)
			{
				res = cb(sources,
				         targetFile().string(),
				         config,
				         settings);
			},
		};
	std::visit(visitor, config.function);
	if(res != 0)
	{
		std::filesystem::remove(targetFile());
	}

	return res;
}

int TaskFn::clean()
{
	if(std::filesystem::exists(targetFile()))
	{
		std::cout << "Removing " << targetFile().string() << "\n";
		std::filesystem::remove(targetFile());
	}

	if(std::filesystem::exists(sourceListFile))
	{
		std::cout << "Removing " << sourceListFile.string() << "\n";
		std::filesystem::remove(sourceListFile);
	}

	return 0;
}

std::vector<std::string> TaskFn::depends() const
{
	return {};
}

std::string TaskFn::target() const
{
	return _targetFile.string();
}

std::filesystem::path TaskFn::targetFile() const
{
	return std::filesystem::path(settings.builddir) / sourceDir / _targetFile;
}

std::string TaskFn::sourceListString() const
{
	std::string sourceListStr;
	for(const auto& source : config.sources)
	{
		sourceListStr += " " + source.file;
	}
	return sourceListStr;
}

bool TaskFn::derived() const
{
	return false;
}

std::string TaskFn::toJSON() const
{
	return {}; // TODO: Not sure how to express this...
}

std::string TaskFn::source() const
{
	return sourceFile.string();
}