#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <stdio.h>
#include <linux/input.h>
#include <errno.h>
#include <stdlib.h>
#include <stdbool.h>

int open_events( int ep );

bool handle_fd( int fd );

void handle_message( struct input_event *ev );

ssize_t file_get_contents( const char *filename, char *buffer, size_t len );

ssize_t file_put_contents( const char *filename, const char *buffer, size_t len );

int _min, _max, _step;
const char *_brightness_file;
bool _all;

int main( int argc, char **argv )
{
	int steps, ep, num, valid;
	struct epoll_event events[10];

	// List all devices by name
	if ( argc > 1 && strcmp( "-l", argv[1] ) == 0 ) {
		open_events( -1 );
		return 0;
	}

	// Listen to all devices
	if ( argc > 1 && strcmp( "-a", argv[1] ) == 0 ) {
		_all = true;
		argc--;
		argv++;
	}

	if ( argc < 5 ) {
		fprintf( stderr, "%s <path> <min> <max> <num_steps>\n", argv[0] );
		return 1;
	}

	// Sanity checks, calculate step size
	_brightness_file = argv[1];
	_min = atoi( argv[2] );
	_max = atoi( argv[3] );
	steps = atoi( argv[4] );
	if ( _max <= _min || steps < 1 ) {
		fprintf( stderr, "Error: min(%d) >= max(%d), or steps(%d) < 1\n", _min, _max, steps );
		return 1;
	}
	_step = ( _max - _min ) / steps;
	if ( _step < 1 ) {
		_step = 1;
	}

	ep = epoll_create( 100 );
	if ( ep == -1 ) {
		perror( "Cannot epoll_create" );
		return 1;
	}

	// Scan all input-event devices, open all that potentially have brightness keys
	// As of now, we match only one so epoll is pointless, but I only checked two
	// laptop models, so maybe there are different ways out there. Let's be prepared.
	valid = open_events( ep );
	if ( valid < 1 ) {
		fprintf( stderr, "Nothing to wait for, exiting\n" );
		return 0;
	}

	printf( "Waiting...\n" );
	while ( ( num = epoll_wait( ep, events, 10, -1 ) ) > 0
			|| ( num == -1 && errno == EINTR ) ) {
		for ( int i = 0; i < num; ++i ) {
			if ( !handle_fd( events[i].data.fd ) ) {
				// Try to remove
				if ( epoll_ctl( ep, EPOLL_CTL_DEL, events[i].data.fd, NULL ) == 0 ) {
					valid--;
					close( events[i].data.fd );
				}
			}
		}
	}
	if ( num == -1 ) {
		perror( "epoll error" );
		return 1;
	}
	fprintf( stderr, "Unexpected loop exit\n" );
	return 0;
}

/**
 * Open all /dev/input/eventX, check the name against known ones with
 * brightness controls.
 * Pass ep == -1 to just print all the device names.
 */
int open_events( int ep )
{
	int opened = 0;
	int fails = 0;
	int h, len;
	char fn[200];

	for ( int id = 0 ;; ++id ) {
		if ( snprintf( fn, sizeof(fn), "/dev/input/event%d", id ) == -1 ) {
			perror( "snprintf broken" );
			break;
		}

		// Open and see if success
		h = open( fn, O_RDONLY );
		if ( h == -1 ) {
			if ( errno == ENOENT ) {
				// Not found - potentially no more devices, but keep going for a bit, since for example
				// unplugging a USB device would leave a gap in the numbering.
				if ( ++fails < 10 )
					continue;
			} else {
				perror( "Cannot open eventX" );
			}
			break;
		}
		// Success, inspect
		if ( ep == -1 ) {
			printf( "Opened %s: ", fn );
		}
		fails = 0;
		len = ioctl( h, EVIOCGNAME( sizeof(fn) ), fn );
		if ( len <= 0 ) {
			perror( "Could not get device name" );
			close( h );
			continue;
		}
		if ( ep == -1 ) {
			printf( "%.*s\n", len, fn );
			close( h );
			continue;
		}

		if ( !_all && strcmp( "Video Bus", fn ) != 0 ) {
			printf( "Ignoring '%s'\n", fn );
			close( h );
			continue;
		}

		printf( "Listening on '%s'\n", fn );
		// Make nonblocking, add to epoll set
		fcntl( h, F_SETFL, O_NONBLOCK );
		struct epoll_event ee = {
			.events = EPOLLIN,
			.data.fd = h,
		};
		if ( epoll_ctl( ep, EPOLL_CTL_ADD, h, &ee ) == -1 ) {
			perror( "Cannot add eventX fd to epoll set" );
			close( h );
		} else {
			opened++;
		}
	}

	return opened;
}

/**
 * Read events from fd.
 */
bool handle_fd( int fd )
{
	int num;
	int done = 0;
	struct input_event buf;

	while ( ( num = read( fd, ( (char*)&buf ) + done, sizeof(buf) - done ) ) > 0
			|| ( num == -1 && errno == EINTR ) ) {
		if ( num + done == sizeof(buf) ) {
			handle_message( &buf );
			if ( done != 0 ) {
				done = 0;
				// Switch to nonblocking again
				fcntl( fd, F_SETFL, O_NONBLOCK );
			}
		} else {
			printf( "WARNING: PARTIAL READ\n" );
			// Switch to blocking so we can finish the message
			fcntl( fd, F_SETFL, 0 );
			done += num;
		}
	}
	if ( num == -1 && errno != EAGAIN ) {
		perror( "Error reading event" );
		return false;
	}
	return true;
}

/**
 * Gets passed read events in input_event struct,
 * check and handle brightness keys.
 */
void handle_message( struct input_event *ev )
{
	ssize_t len;
	int val, newval;
	char buf[100];

	//printf( "Type: %d, Key %d, Value %d\n", (int)ev->type, (int)ev->code, (int)ev->value );
	if ( ev->type != EV_KEY )
		return;
	if ( ev->value != 1 && ev->value != 2 )
		return; // Down or Repeat only
	if ( ev->code != KEY_BRIGHTNESSDOWN && ev->code != KEY_BRIGHTNESSUP )
		return; // Match our keys

	// Get current brightness
	len = file_get_contents( _brightness_file, buf, sizeof(buf) );
	if ( len <= 0 ) {
		fprintf( stderr, "Cannot read brightness\n" );
		return;
	}

	// Calculate new brightness
	val = atoi( buf );
	newval = val +  _step * ( ev->code == KEY_BRIGHTNESSUP ? 1 : -1 );
	if ( newval < _min ) {
		newval = _min;
	} else if ( newval > _max ) {
		newval = _max;
	}
	if ( val == newval )
		return;

	// Set new brightness
	len = snprintf( buf, sizeof(buf), "%d", newval );
	if ( len == -1 ) {
		perror( "Brightness snprintf fail" );
	} else if ( len == 0 ) {
		fprintf( stderr, "Brightness snprintf returned zero\n" );
	} else {
		file_put_contents( _brightness_file, buf, (size_t)len );
	}
}

/**
 * Read file contents into buffer.
 */
ssize_t file_get_contents( const char *filename, char *buffer, size_t len )
{
	ssize_t ret;
	size_t done = 0;
	ssize_t bytes_read = -1;
	int fd;

	if ( len <= 1 ) {
		if ( len == 1 ) {
			buffer[0] = '\0';
		}
		return 0;
	}
	len--;

	fd = open( filename, O_RDONLY );
	if ( fd == -1 ) {
		fprintf( stderr, "%s: ", filename );
		perror( "Error opening file" );
		return -1;
	}

	while ( done < len && ( bytes_read = read( fd, buffer + done, len - done ) ) > 0 ) {
		done += bytes_read;
	}
	if ( bytes_read == -1 ) {
		fprintf( stderr, "%s: ", filename );
		perror( "Error reading file" );
		ret = -1;
	} else {
		ret = (ssize_t)done;
		buffer[done] = '\0';
	}

	close( fd );
	return ret;
}

/**
 * Write buffer contents to file.
 */
ssize_t file_put_contents( const char *filename, const char *buffer, size_t len )
{
	ssize_t ret;
	size_t done = 0;
	ssize_t bytes_written = -1;
	int fd = open( filename, O_WRONLY | O_CREAT | O_TRUNC, 0644 );

	if ( fd == -1 ) {
		fprintf( stderr, "%s: ", filename );
		perror( "Error opening file" );
		return -1;
	}

	while ( done < len && ( bytes_written = write( fd, buffer + done, len - done ) ) > 0 ) {
		done += bytes_written;
	}
	if ( bytes_written == -1 ) {
		fprintf( stderr, "%s: ", filename );
		perror( "Error writing file" );
		ret = -1;
	} else {
		ret = (ssize_t)done;
	}
	close( fd );
	return ret;
}