license.ts

import { homedir, platform } from "node:os";
import { join } from "node:path";

import type { CancellationToken, LogOutputChannel } from "vscode";

import { execLocalStack } from "./cli.ts";
import type { CliStatusTracker } from "./cli.ts";
import { createFileStatusTracker } from "./file-status-tracker.ts";
import type { StatusTracker } from "./file-status-tracker.ts";

/**
 * See https://github.com/localstack/localstack/blob/de861e1f656a52eaa090b061bd44fc1a7069715e/localstack-core/localstack/utils/files.py#L38-L55.
 * @returns The cache directory for the current platform.
 */
const cacheDirectory = () => {
	switch (platform()) {
		case "win32":
			return join(process.env.LOCALAPPDATA!, "cache");
		case "darwin":
			return join(homedir(), "Library", "Caches");
		default:
			return process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache");
	}
};

/**
 * The file that contains the license information of the LocalStack CLI.
 *
 * The license file is stored in the cache directory for the current platform.
 */
export const LICENSE_FILENAME = join(
	cacheDirectory(),
	"localstack-cli",
	"license.json",
);

const LICENSE_VALIDITY_MARKER = "license validity: valid";

export async function checkIsLicenseValid(
	cliPath: string,
	outputChannel: LogOutputChannel,
) {
	try {
		const licenseInfoResponse = await execLocalStack(
			cliPath,
			["license", "info"],
			{
				outputChannel,
			},
		);
		return licenseInfoResponse.stdout.includes(LICENSE_VALIDITY_MARKER);
	} catch (error) {
		outputChannel.error(error instanceof Error ? error : String(error));

		return false;
	}
}

export async function activateLicense(
	cliPath: string,
	outputChannel: LogOutputChannel,
) {
	try {
		await execLocalStack(cliPath, ["license", "activate"], {
			outputChannel,
		});
	} catch (error) {
		outputChannel.error(error instanceof Error ? error : String(error));
	}
}

export async function activateLicenseUntilValid(
	cliPath: string,
	outputChannel: LogOutputChannel,
	cancellationToken: CancellationToken,
): Promise<void> {
	while (true) {
		if (cancellationToken.isCancellationRequested) {
			break;
		}
		const licenseIsValid = await checkIsLicenseValid(cliPath, outputChannel);
		if (licenseIsValid) {
			break;
		}
		await activateLicense(cliPath, outputChannel);
		// Wait before trying again
		await new Promise((resolve) => setTimeout(resolve, 1000));
	}
}

/**
 * Creates a status tracker that monitors the LocalStack license file for changes.
 * When the file is changed, the provided check function is called to determine the current setup status.
 * Emits status changes to registered listeners.
 *
 * @param outputChannel - Channel for logging output and trace messages.
 * @returns A {@link StatusTracker} instance for querying status, subscribing to changes, and disposing resources.
 */
export function createLicenseStatusTracker(
	cliTracker: CliStatusTracker,
	authTracker: StatusTracker,
	outputChannel: LogOutputChannel,
): StatusTracker {
	const licenseTracker = createFileStatusTracker(
		outputChannel,
		"[setup-status.license]",
		[LICENSE_FILENAME],
		async () => {
			if (cliTracker.outdated()) {
				return "setup_required";
			}

			const cliPath = cliTracker.cliPath();
			if (!cliPath) {
				return "waiting_for_dependencies";
			}

			const isLicenseValid = await checkIsLicenseValid(cliPath, outputChannel);

			return isLicenseValid ? "ok" : "setup_required";
		},
	);

	authTracker.onChange(() => {
		licenseTracker.check();
	});

	cliTracker.onCliPathChange(() => {
		licenseTracker.check();
	});

	cliTracker.onOutdatedChange(() => {
		licenseTracker.check();
	});

	return licenseTracker;
}