/*
 * Copyright (c) 2013, 2014, 2016, 2024 Jonas 'Sortie' Termansen.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 */

#include <stdbool.h>
#include <string.h>
#include <unistd.h>
#include <wchar.h>

#define MAX_TERMSEQ_SIZE 16

struct editor_input
{
	mbstate_t ps;
	char termseq[MAX_TERMSEQ_SIZE];
	size_t termseq_used;
	size_t termseq_seen;
};

struct terminal_sequence
{
	const char* sequence;
	int kbkey;
	bool control;
	bool shift;
};

#define KBKEY_UP (0x80 + 0x48)

struct terminal_sequence terminal_sequences[] =
{
	{ "\e[1;2A", KBKEY_UP, false, true },
};

void editor_emulate_kbkey(int kbkey,
                          bool control,
                          bool shift);

void editor_input_process_byte(struct editor_input* editor_input)
{
	unsigned char uc;
	if ( read(0, &uc, 1) != 1 )
		return;

	if ( editor_input->termseq_used < MAX_TERMSEQ_SIZE )
	// gcc -std=gnu11 -O2 -g -Werror -Werror=strict-prototypes -Wall -Wextra  -c repro.c -o repro.o -D_GNU_SOURCE
	// repro.c:61:71: error: dangling pointer to ‘uc’ may be used [-Werror=dangling-pointer=]
		editor_input->termseq[editor_input->termseq_used++] = (char) uc;
	//                                                        ^~~~~~~~~

	size_t num_seqs = sizeof(terminal_sequences) / sizeof(terminal_sequences[0]);

	while ( editor_input->termseq_seen < editor_input->termseq_used )
	{
		size_t match = 0;
		size_t match_size = 0;
		bool full_match = false;
		bool partial_match = false;

		for ( size_t i = 0; i < num_seqs; i++ )
		{
			struct terminal_sequence* terminal_sequence = &terminal_sequences[i];
			const char* sequence = terminal_sequence->sequence;

			bool potential_partial_match = false;
			for ( size_t n = 0; n < editor_input->termseq_used; n++ )
			{
				if ( sequence[n] != editor_input->termseq[n] )
				{
					potential_partial_match = false;
					break;
				}

				if ( sequence[n+1] == '\0' )
				{
					potential_partial_match = false;
					full_match = true;
					match = i;
					match_size = n + 1;
					break;
				}

				potential_partial_match = true;
			}

			if ( potential_partial_match )
				partial_match = true;
		}

		if ( full_match )
		{
			editor_emulate_kbkey(terminal_sequences[match].kbkey,
			                     terminal_sequences[match].control,
			                     terminal_sequences[match].shift);
			memmove(editor_input->termseq,
			        editor_input->termseq + match_size,
			        editor_input->termseq_used - match_size);
			editor_input->termseq_used -= match_size;
			editor_input->termseq_seen = 0;
			continue;
		}

		if ( partial_match )
		{
			editor_input->termseq_seen = editor_input->termseq_used;
			continue;
		}

		char input = editor_input->termseq[0];

		if ( 1 <= input && input <= 26 && input != '\t' && input != '\n' )
		{

		}
		else
		{
			wchar_t wc;
			size_t amount = mbrtowc(&wc, &input, 1, &editor_input->ps);
			if ( amount == (size_t) -1 )
				memset(&editor_input->ps, 0, sizeof(editor_input->ps));
		}

		memmove(editor_input->termseq,
		        editor_input->termseq + 1,
		        editor_input->termseq_used - 1);
		editor_input->termseq_used--;
		editor_input->termseq_seen = 0;
	}
}

void editor_input_process(struct editor_input* editor_input)
{
	editor_input_process_byte(editor_input);
}