/*-
 * redshift-ng - Automatically adjust display colour temperature according the Sun
 * 
 * Copyright (c) 2009-2018        Jon Lund Steffensen <jonlst@gmail.com>
 * Copyright (c) 2014-2016, 2025  Mattias Andrée <m@maandree.se>
 * 
 * redshift-ng 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 3 of the License, or
 * (at your option) any later version.
 * 
 * redshift-ng 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 redshift-ng.  If not, see <http://www.gnu.org/licenses/>.
 */
#include "common.h"


/**
 * Union of libgamma gamma ramp structures
 */
union gamma_ramps {
	/**
	 * Gamma ramp sizes
	 */
	struct {
		size_t red;   /**< Size of the gamma ramp for the red channel */
		size_t green; /**< Size of the gamma ramp for the green channel */
		size_t blue;  /**< Size of the gamma ramp for the blue channel */
	} size;

	/* Ramp structures */
#define X(SUFFIX, RAMPS, TYPE, MAX, DEPTH)\
	struct libgamma_gamma_##RAMPS RAMPS
	LIST_RAMPS_STOP_VALUE_TYPES(X, ;);
#undef X
};


/**
 * State for partition (e.g. X screen or graphics card)
 */
struct partition_state {
	/**
	 * libgamma state
	 */
	struct libgamma_partition_state state;

	/**
	 * Index of CRTC when indexing spans multiple X screens
	 */
	size_t crtc_num_offset;
};


/**
 * CRTC state
 */
struct crtc_state {
	/**
	 * libgamma state
	 */
	struct libgamma_crtc_state state;

	/**
	 * Gamma ramp depth, 0 if uninitialised,
	 * -1 if single-precision float,
	 * -2 if double-precision float,
	 * otherwise the number of bits (of unsigned integer)
	 */
	signed gamma_depth;

	/**
	 * Gamma ramps used by the gamma adjustment function
	 */
	union gamma_ramps gamma_ramps;

	/**
	 * Original state of gamma ramps
	 */
	union gamma_ramps saved_gamma_ramps;
};


struct gamma_state {
	/**
	 * libgamma state for the site (e.g. X display)
	 */
	struct libgamma_site_state site;

	/**
	 * Whether the adjustment method supports multiple
	 * sites rather than just the default site
	 */
	unsigned multiple_sites : 1;

	/**
	 * Whether the adjustment method supports multiple partitions
	 * per site
	 */
	unsigned multiple_partitions : 1;

	/**
	 * Whether the adjustment method supports multiple CRTC:s
	 * per partition per site
	 */
	unsigned multiple_crtcs : 1;

	/**
	 * Whether partitions are graphics cards
	 */
	unsigned partitions_are_graphics_cards : 1;

	/**
	 * Whether a parition has been selected
	 */
	unsigned partition_selected : 1;

	/**
	 * Whether CRTCs have been selected
	 */
	unsigned crtcs_selected : 1;

	/**
	 * Selected parition (if `partition_selected`)
	 */
	size_t selected_partition;

	/**
	 * Number of selected CRTCs
	 */
	size_t ncrtcs;

	/**
	 * Number of selected parition
	 */
	size_t npartitions;

	/**
	 * Indices of selected CRTCs
	 */
	size_t *selected_crtcs;

	/**
	 * State for selected paritions
	 */
	struct partition_state *partitions;

	/**
	 * State for selected CRTCs
	 */
	struct crtc_state *crtcs;
};


int
direct_create(struct gamma_state **state_out, int method, const char *method_name)
{
	struct libgamma_method_capabilities caps;
	struct gamma_state *state;
	int err;

	*state_out = NULL;

	if (!libgamma_is_method_available(method)) {
		weprintf(_("Adjustment method `%s' is not available"), method_name);
		return -1;
	}

	err = libgamma_method_capabilities(&caps, sizeof(caps), method);
	if (err) {
		weprintf("libgamma_method_capabilities %s: %s", libgamma_const_of_method(method), libgamma_strerror(err));
		return -1;
	}

	state = *state_out = ecalloc(1, sizeof(**state_out));
	state->selected_crtcs = NULL;
	state->partitions = NULL;
	state->multiple_sites = caps.multiple_sites;
	state->multiple_partitions = caps.multiple_partitions;
	state->multiple_crtcs = caps.multiple_crtcs;
	state->partitions_are_graphics_cards = caps.partitions_are_graphics_cards;
	
	err = libgamma_site_initialise(&state->site, method, NULL);
	if (err) {
		weprintf("libgamma_site_initialise %s NULL: %s", libgamma_const_of_method(method), libgamma_strerror(err));
		free(state);
		*state_out = NULL;
		return -1;
	}

	return 0;
}


void
direct_print_help(FILE *f, int method)
{
	struct libgamma_method_capabilities caps;

	if (libgamma_method_capabilities(&caps, sizeof(caps), method)) {
		fprintf(f, _("Adjustment not available\n"));
		fprintf(f, "\n");
		return;
	}

	if (caps.multiple_partitions && caps.partitions_are_graphics_cards)
		/* TRANSLATORS: "N" represents "number"; right-pad with spaces to preserve display width */
		fprintf(f, "  card=%s   %s\n", _("N     "), _("Graphics card to apply adjustments to"));
	else if (caps.multiple_partitions)
		fprintf(f, "  screen=%s %s\n", _("N     "), _("X screen to apply adjustments to"));

	if (caps.multiple_crtcs)
		fprintf(f, "  crtc=%s   %s\n", _("N     "), _("List of comma-separated CRTCs to apply adjustments to"));

	if (caps.multiple_partitions || caps.multiple_crtcs)
		fprintf(f, "\n";
}


int
direct_set_option(struct gamma_state *state, const char *key, const char *value)
{
	if (state->multiple_partitions && !strcasecmp(key, state->partitions_are_graphics_cards ? "card" : "screen")) {
		return direct_set_partitions(state, key, value);
	} else if (state->multiple_crtcs && !strcasecmp(key, "crtc")) {
		return direct_set_crtcs(state, key, value);
	} else if (!strcasecmp(key, "preserve")) {
		weprintf(_("Deprecated method parameter ignored: `%s'."), key);
		return 0;
	} else {
		weprintf(_("Unknown method parameter: `%s'."), key);
		return -1;
	}
}


int
direct_set_partitions(struct gamma_state *state, const char *key, const char *value)
{
	const char *end;
	uintmax_t num;

	/* Check previously unspecified */
	if (state->partition_selected)
		weprintf(_("`%s' option specified multiple times, using last selection."), key);
	state->partition_selected = 1;

	/* Parse number */
	errno = 0;
	num = strtoumax(value, (void *)&end, 10);
	state->selected_partition = (size_t)num;
	if (num > (uintmax_t)SIZE_MAX || *end || !isdigit(*value) || errno)
		eprintf(_("Invalid value of `%s' option: `%s'."), key, value);

	return 0;
}


int
direct_set_crtcs(struct gamma_state *state, const char *key, const char *value)
{
	const char *end, *p;
	uintmax_t num;
	size_t count;

	/* Check previously unspecified */
	if (state->crtcs_selected)
		weprintf(_("`%s' option specified multiple times, using last selection."), key);
	state->crtcs_selected = 1;

	/* Check if all are selected */
	state->ncrtcs = 0;
	free(state->selected_crtcs);
	state->selected_crtcs = NULL;
	if (!*value || !strcasecmp(value, "all"))
		return 0;

	/* Get number count */
	for (p = value, count = 1; *p; p++)
		if (*p == ',')
			count++;
	state->selected_crtcs = ecalloc(count, sizeof(*state->selected_crtcs));

	/* Parse numbers */
	errno = 0;
	for (p = value; *p; p = end) {
		num = strtoumax(p, (void *)&end, 10);
		state->selected_crtcs[state->ncrtcs++] = (size_t)num;
		if (num > (uintmax_t)SIZE_MAX || (*end && *end != ',') || !isdigit(*p) || errno)
			eprintf(_("Invalid value of `%s' option: `%s'."), key, value);
		end = &end[*end == ','];
	}

	return 0;
}


int
direct_start(struct gamma_state *state)
{

	struct libgamma_crtc_information crtc_info;
	size_t crtc_num_offset = 0;
	size_t crtcs_removed = 0;
	size_t i, j, k, num, part;
	int err;

	/* Allocate partition states */
	if (state->partition_selected) {
		state->partitions = ecalloc(1, sizeof(*state->partitions));
		state->partitions[0].state.partition = state->selected_partition;
		state->partitions[0].state.data = NULL;
		state->npartitions = 1;
	} else if (!state->site.partitions_available) {
		if (state->partitions_are_graphics_cards)
			weprintf(_("No graphics card found."));
		else
			weprintf(_("No X screen found."));
		return -1;
	} else {
		state->npartitions = state->site.partitions_available;
		state->partitions = ecalloc(state->npartitions, sizeof(*state->partitions));
		for (i = 0; i < state->npartitions; i++) {
			state->partitions[i].state.partition = i;
			state->partitions[i].state.data = NULL;
		}
	}

	/* Initialise partitions */
	for (i = 0; i < state->npartitions; i++) {
		num = state->partitions[i].state.partition;
		err = libgamma_partition_initialise(&state->partitions[i].state, &state->site, num);
		if (err) {
			weprintf("libgamma_partition_initialise %zu: %s", num, libgamma_strerror(err));
			return -1;
		}
		state->partitions[i].crtc_num_offset = crtc_num_offset;
		crtc_num_offset += state->partitions[i].state.crtcs_available;
	}

	/* Allocate CRTCs states and map to partition–CRTC pairs */
	if (state->ncrtcs) {
		state->crtcs = ecalloc(state->ncrtcs, sizeof(*state->crtcs));
		for (i = 0; i < state->ncrtcs; i++) {
			state->crtcs[i].state.data = NULL;
			state->crtcs[i].state.crtc = state->selected_crtcs[i];
		}
		for (i = 0; i < state->ncrtcs; i++) {
			for (j = 1; j < state->npartitions; j++)
				if (state->crtcs[i].state.crtc < state->partitions[j].crtc_num_offset)
					break;
			state->crtcs[i].state.partition = &state->partitions[j - 1U].state;
		}
	} else if (!crtc_num_offset) {
		weprintf(_("No CRTCs found."));
		return -1;
	} else {
		state->ncrtcs = crtc_num_offset;
		state->crtcs = ecalloc(state->ncrtcs, sizeof(*state->crtcs));
		for (j = 0, i = 0; j < state->npartitions; j++) {
			for (k = 0; k < state->partitions[j].state.crtcs_available; k++, i++) {
				state->crtcs[i].state.data = NULL;
				state->crtcs[i].state.partition = &state->partitions[j].state;
				state->crtcs[i].state.crtc = k;
			}
		}
	}

	/* Initialise CRTCs and fetch original gamma adjustments */
	for (i = 0; i < state->ncrtcs; i++) {
		/* Get CRTC */
		part = state->crtcs[i].state.partition->partition;
		num = state->crtcs[i].state.crtc;
		err = libgamma_crtc_initialise(&state->crtcs[i].state, state->crtcs[i].state.partition, num);
		if (err) {
			weprintf("libgamma_crtc_initialise %zu %zu: %s", part, num, libgamma_strerror(err));
			return -1;
		}

		/* Get gamma ramp inforamtion for CRTC */
		libgamma_get_crtc_information(&crtc_info, sizeof(crtc_info), &state->crtcs[i].state,
		                              LIBGAMMA_CRTC_INFO_GAMMA_SIZE |
		                              LIBGAMMA_CRTC_INFO_GAMMA_DEPTH |
		                              LIBGAMMA_CRTC_INFO_GAMMA_SUPPORT);
		if (crtc_info.gamma_size_error || crtc_info.gamma_depth_error) {
			libgamma_crtc_destroy(&state->crtcs[i].state);
			state->crtcs[i].state.data = NULL;
			crtcs_removed++;
			goto no_gamma_support;
		}
		if (!crtc_info.gamma_support_error && crtc_info.gamma_support == LIBGAMMA_NO) {
		no_gamma_support:
			if (state->multiple_crtcs) {
				if (!state->multiple_partitions)
					weprintf(_("Adjustments are not supported on CRTC %zu."), num);
				else if (state->partitions_are_graphics_cards)
					weprintf(_("Adjustments are not supported on CRTC %zu on graphics card %zu."), num, part);
				else
					weprintf(_("Adjustments are not supported on CRTC %zu on X screen %zu."), num, part);
			} else {
				if (!state->multiple_partitions)
					weprintf(_("Adjustments are not supported."));
				else if (state->partitions_are_graphics_cards)
					weprintf(_("Adjustments are not supported on graphics card %zu."), part);
				else
					weprintf(_("Adjustments are not supported on X screen %zu."), part);
			}
			if (!state->crtcs[i].state.data)
				goto next;
		}

		/* Initialise and fetch gamma adjustments */
		state->crtcs[i].gamma_ramps.size.red   = crtc_info.red_gamma_size;
		state->crtcs[i].gamma_ramps.size.green = crtc_info.green_gamma_size;
		state->crtcs[i].gamma_ramps.size.blue  = crtc_info.blue_gamma_size;
		state->crtcs[i].saved_gamma_ramps.size.red   = crtc_info.red_gamma_size;
		state->crtcs[i].saved_gamma_ramps.size.green = crtc_info.green_gamma_size;
		state->crtcs[i].saved_gamma_ramps.size.blue  = crtc_info.blue_gamma_size;
		switch (crtc_info.gamma_depth) {
#define X(SUFFIX, RAMPS, TYPE, MAX, DEPTH)\
		case DEPTH:\
			if (libgamma_gamma_##RAMPS##_initialise(&state->crtcs[i].gamma_ramps.RAMPS) ||\
			    libgamma_gamma_##RAMPS##_initialise(&state->crtcs[i].saved_gamma_ramps.RAMPS))\
				eprintf("libgamma_gamma_"#RAMPS"_initialise:");\
			j = 0;\
			do {\
				err = libgamma_crtc_get_gamma_##RAMPS(&state->crtcs[i].state,\
				                                      &state->crtcs[i].saved_gamma_ramps.RAMPS);\
			} while (err && j++ < 10);\
			if (!err) {\
				state->crtcs[i].gamma_depth = DEPTH;\
				break;\
			}\
			if (state->multiple_crtcs) {\
				if (!state->multiple_partitions)\
					weprintf(_("Could not get current adjustments for CRTC %zu."), num);\
				else if (state->partitions_are_graphics_cards)\
					weprintf(_("Could not get current adjustments for CRTC %zu on graphics card %zu."), num, part);\
				else\
					weprintf(_("Could not get current adjustments for CRTC %zu on X screen %zu."), num, part);\
			} else {\
				if (!state->multiple_partitions)\
					weprintf(_("Could not get current adjustments."));\
				else if (state->partitions_are_graphics_cards)\
					weprintf(_("Could not get current adjustments for graphics card %zu."), part);\
				else\
					weprintf(_("Could not get current adjustments for X screen %zu."), part);\
			}\
			libgamma_gamma_##RAMPS##_destroy(&state->crtcs[i].gamma_ramps.RAMPS);\
			libgamma_gamma_##RAMPS##_destroy(&state->crtcs[i].saved_gamma_ramps.RAMPS);\
			libgamma_crtc_destroy(&state->crtcs[i].state);\
			state->crtcs[i].state.data = NULL;\
			crtcs_removed++;\
			goto next

			LIST_RAMPS_STOP_VALUE_TYPES(X, ;);
#undef X

		default:
			if (state->multiple_crtcs) {
				if (!state->multiple_partitions)
					weprintf(_("Unsupported gamma ramp type on CRTC %zu."), num);
				else if (state->partitions_are_graphics_cards)
					weprintf(_("Unsupported gamma ramp type on CRTC %zu on graphics card %zu."), num, part);
				else
					weprintf(_("Unsupported gamma ramp type on CRTC %zu on X screen %zu."), num, part);
			} else {
				if (!state->multiple_partitions)
					weprintf(_("Unsupported gamma ramp type."));
				else if (state->partitions_are_graphics_cards)
					weprintf(_("Unsupported gamma ramp type on graphics card %zu."), part);
				else
					weprintf(_("Unsupported gamma ramp type on X screen %zu."), part);
			}
			return -1;
		}

	next:
		libgamma_crtc_information_destroy(&crtc_info);
	}

	/* Unlist removed CRTCs */
	if (crtcs_removed) {
		num = state->ncrtcs - crtcs_removed;
		for (i = j = 0; crtcs_removed; i++, j++)
			if (!state->crtcs[i].state.data)
				break;
		for (; crtcs_removed; i++) {
			if (state->crtcs[i].state.data)
				crtcs_removed--;
			else
				memmove(&state->crtcs[j++], &state->crtcs[i], sizeof(*state->crtcs));
		}
		memmove(&state->crtcs[j], &state->crtcs[i], (state->ncrtcs - i) * sizeof(*state->crtcs));
		state->ncrtcs = num;
	}
	if (!state->ncrtcs) {
		weprintf(_("No usable CRTCs available."));
		return -1;
	}

	return 0;
}


int
direct_apply(struct gamma_state *state, const struct colour_setting *setting, int preserve /* TODO */)
{
	size_t i, err_count = 0, crtc, part;
	const char *errstr;
	int err;

	for (i = 0; i < state->ncrtcs; i++) {
		switch (state->crtcs[i].gamma_depth) {
#define X(SUFFIX, RAMPS, TYPE, MAX, DEPTH)\
		case DEPTH:\
			fill_ramps_##SUFFIX(state->crtcs[i].gamma_ramps.RAMPS.red,\
			                    state->crtcs[i].gamma_ramps.RAMPS.green,\
			                    state->crtcs[i].gamma_ramps.RAMPS.blue,\
			                    state->crtcs[i].gamma_ramps.size.red,\
			                    state->crtcs[i].gamma_ramps.size.green,\
			                    state->crtcs[i].gamma_ramps.size.blue,\
			                    setting);\
			err = libgamma_crtc_set_gamma_##RAMPS(&state->crtcs[i].state, &state->crtcs[i].gamma_ramps.RAMPS);\
			break

			LIST_RAMPS_STOP_VALUE_TYPES(X, ;);
#undef X

		default:
			err_count++;
			err = 0;
			break;
		}
		
		if (err) {
			err_count++;
			crtc = state->crtcs[i].state.crtc;
			part = state->crtcs[i].state.partition->partition;
			errstr = libgamma_strerror(err);
			if (state->multiple_crtcs) {
				if (!state->multiple_partitions)
					weprintf(_("Unable to set adjustments for CRTC %zu: %s."), crtc, errstr);
				else if (state->partitions_are_graphics_cards)
					weprintf(_("Unable to set adjustments for CRTC %zu on graphics card %zu: %s."),
					         crtc, part, errstr);
				else
					weprintf(_("Unable to set adjustments for CRTC %zu on X screen %zu: %s."),
					         crtc, part, errstr);
			} else {
				if (!state->multiple_partitions)
					weprintf(_("Unable to set adjustments: %s."), errstr);
				else if (state->partitions_are_graphics_cards)
					weprintf(_("Unable to set adjustments for graphics card %zu: %s."), part, errstr);
				else
					weprintf(_("Unable to set adjustments for X screen %zu: %s."), part, errstr);
			}
		}
	}

	return err_count == state->ncrtcs ? -1 : 0;
}


void
direct_restore(struct gamma_state *state)
{
	size_t i, crtc, part;
	const char *errstr;
	int err;

	for (i = 0; i < state->ncrtcs; i++) {
		switch (state->crtcs[i].gamma_depth) {
#define X(SUFFIX, RAMPS, TYPE, MAX, DEPTH)\
		case DEPTH:\
			err = libgamma_crtc_set_gamma_##RAMPS(&state->crtcs[i].state, &state->crtcs[i].saved_gamma_ramps.RAMPS);\
			break

			LIST_RAMPS_STOP_VALUE_TYPES(X, ;);
#undef X

		default:
			err = 0;
			break;
		}

		if (err) {
			crtc = state->crtcs[i].state.crtc;
			part = state->crtcs[i].state.partition->partition;
			errstr = libgamma_strerror(err);
			if (state->multiple_crtcs) {
				if (!state->multiple_partitions)
					weprintf(_("Unable to restore adjustments for CRTC %zu: %s."), crtc, errstr);
				else if (state->partitions_are_graphics_cards)
					weprintf(_("Unable to restore adjustments for CRTC %zu on graphics card %zu: %s."),
					         crtc, part, errstr);
				else
					weprintf(_("Unable to restore adjustments for CRTC %zu on X screen %zu: %s."),
					         crtc, part, errstr);
			} else {
				if (!state->multiple_partitions)
					weprintf(_("Unable to restore adjustments: %s."), errstr);
				else if (state->partitions_are_graphics_cards)
					weprintf(_("Unable to restore adjustments for graphics card %zu: %s."), part, errstr);
				else
					weprintf(_("Unable to restore adjustments for X screen %zu: %s."), part, errstr);
			}
		}
	}
}


void
direct_free(struct gamma_state *state)
{
	size_t i;
	if (state->crtcs) {
		for (i = 0; i < state->ncrtcs; i++) {
			switch (state->crtcs[i].gamma_depth) {
#define X(SUFFIX, RAMPS, TYPE, MAX, DEPTH)\
			case DEPTH:\
				libgamma_gamma_##RAMPS##_destroy(&state->crtcs[i].gamma_ramps.RAMPS);\
				libgamma_gamma_##RAMPS##_destroy(&state->crtcs[i].saved_gamma_ramps.RAMPS);\
				break
				LIST_RAMPS_STOP_VALUE_TYPES(X, ;);
#undef X
			default:
			case 0: /* not initialised */
				break;
			}
			if (state->crtcs[i].state.data)
				libgamma_crtc_destroy(&state->crtcs[i].state);
		}
		free(state->crtcs);
	}
	if (state->partitions) {
		for (i = 0; i < state->npartitions; i++)
			if (state->partitions[i].state.data)
				libgamma_partition_destroy(&state->partitions[i].state);
		free(state->partitions);
	}
	free(state->selected_crtcs);
	libgamma_site_destroy(&state->site);
	free(state);
}