/*

  pkgit - package it!

  Copyright (C) 2026 dacctal
  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <https://www.gnu.org/licenses/>.

*/

#include <unistd.h>

#include "common.h"
#include "files.h"
#include "log.h"
#include "pkg.h"
#include "state.h"

#define try_pkg_fn(fn, pkg, operation)                                         \
	do {                                                                       \
		log_info("attempting to %s '%.*s'", operation, str_fmt(&(pkg)->name)); \
		if (!(fn((pkg)))) {                                                    \
			log_error("%s failed", operation);                                 \
			return false;                                                      \
		}                                                                      \
	} while (0)

static bool pkg_write_status(const char *status, package_t *pkg) {
	bool success = false;
	str status_str = mstr(status);
	str pkgit_status = str_format("%.*s/.pkgit_status", str_fmt(&pkg->src));
	success = file_write(&status_str, &pkgit_status);
	str_free(&pkgit_status);
	str_free(&status_str);
	return success;
}

static bool pkg_read_status(const char desired, package_t *pkg) {
	bool success = false;
	str pkgit_status = str_format("%.*s/.pkgit_status",
		str_fmt(&pkg->src));
	str status = file_read(&pkgit_status);
	success = str_find_char(&status, desired);
	str_free(&pkgit_status);
	str_free(&status);
	return success;
}

static bool is_pkg_installed(package_t *pkg) {
	if (pkg_read_status('i', pkg)) {
		if (flags.force) log_warn(
			"%.*s is already installed",
			str_fmt(&pkg->name));
		else log_info(
			"%.*s is already installed",
			str_fmt(&pkg->name));
		return true;
	} else return false;
}

static bool pkg_fetch_sources(package_t *pkg) {
	bool success = false;
	if (!pkg_hook_fetch_sources(pkg)) {
		log_error(GREEN "%.*s" COLOR_RESET " fetch failed",
			str_fmt(&pkg->name));
		return false;
	}
	success = pkg_write_status("f", pkg);
	return success;
}

static bool pkg_enter(package_t *pkg) {
	if (!is_directory(pkg->src.data)) {
		log_error(GREEN "%.*s" COLOR_RESET " is not a directory",
			str_fmt(&pkg->src));
		return false;
	}
	chdir(pkg->src.data);
	if (!pkg_write_status("e", pkg)) return false;
	return true;
}

bool pkg_setup(package_t *pkg) {
	if (pkg_read_status('s', pkg)) return true;
	try_pkg_fn(pkg_enter, pkg, "enter");
	try_pkg_fn(pkg_hook_setup, pkg, "setup");
	if (!pkg_write_status("s", pkg)) return false;
	return true;
}

bool pkg_build(package_t *pkg) {
	if (pkg_read_status('b', pkg)) return true;
	try_pkg_fn(pkg_enter, pkg, "enter");
	try_pkg_fn(pkg_hook_build, pkg, "build");
	if (!pkg_write_status("b", pkg)) return false;
	return true;
}

bool pkg_install(package_t *pkg) {
	if (is_pkg_installed(pkg) && !flags.force) return true;
	log_info("fetching '%.*s'", str_fmt(&pkg->name));
	if (!pkg_read_status('f', pkg) && !pkg_fetch_sources(pkg)) return false;
	log_info("entering '%.*s'", str_fmt(&pkg->src));
	if (!pkg_read_status('e', pkg) && !pkg_enter(pkg)) return false;
	log_info("setting up '%.*s'", str_fmt(&pkg->name));
	if (!pkg_read_status('s', pkg) && !pkg_hook_setup(pkg)) return false;
	log_info("building '%.*s'", str_fmt(&pkg->name));
	if (!pkg_read_status('b', pkg) && !pkg_hook_build(pkg)) return false;
	log_info("installing '%.*s'", str_fmt(&pkg->name));
	if (!pkg_hook_install(pkg)) return false;
	if (!pkg_write_status("i", pkg)) return false;
	log_success("installed '%.*s'", str_fmt(&pkg->name));
	return true;
}

bool pkg_remove(package_t *pkg) {
	if (!pkg_enter(pkg)) return false;
	if (!pkg_hook_remove(pkg)) return false;
	if (!rmrf(&pkg->root)) return false;
	log_success("removed '%.*s'", str_fmt(&pkg->name));
	return true;
}

bool pkg_update(package_t *pkg) {
	pkg_install(pkg);
	return true;
}