#include <stdio.h>

#include <unistd.h>

#include <errno.h>

#include <stdlib.h>

#include <string.h>

#include <yaml.h>

#include "yaml-path.h"

int parse_and_emit (yaml_parser_t *parser, yaml_emitter_t *emitter, yaml_path_t *path, yaml_path_filter_mode_t mode, int use_flow_style)

{

	yaml_event_t event;

	yaml_event_type_t prev_event_type, event_type;

	do {

		if (!yaml_parser_parse(parser, &event)) {

			switch (parser->error) {

			case YAML_MEMORY_ERROR:

				fprintf(stderr, "Memory error: Not enough memory for parsing\n");

				break;

			case YAML_READER_ERROR:

				if (parser->problem_value != -1) {

					fprintf(stderr, "Reader error: %s: #%X at %ld\n", parser->problem, parser->problem_value, (long)parser->problem_offset);

				} else {

					fprintf(stderr, "Reader error: %s at %ld\n", parser->problem, (long)parser->problem_offset);

				}

				break;

			case YAML_SCANNER_ERROR:

				if (parser->context) {

					fprintf(stderr, "Scanner error: %s at line %d, column %d\n%s at line %d, column %d\n", parser->context,

					       (int)parser->context_mark.line+1,(int)parser->context_mark.column+1, parser->problem,

					       (int)parser->problem_mark.line+1, (int)parser->problem_mark.column+1);

				} else {

					fprintf(stderr, "Scanner error: %s at line %d, column %d\n", parser->problem, (int)parser->problem_mark.line+1, (int)parser->problem_mark.column+1);

				}

				break;

			case YAML_PARSER_ERROR:

				if (parser->context) {

					fprintf(stderr, "Parser error: %s at line %d, column %d\n%s at line %d, column %d\n", parser->context,

					       (int)parser->context_mark.line+1, (int)parser->context_mark.column+1, parser->problem,

					       (int)parser->problem_mark.line+1, (int)parser->problem_mark.column+1);

				} else {

					fprintf(stderr, "Parser error: %s at line %d, column %d\n", parser->problem, (int)parser->problem_mark.line+1, (int)parser->problem_mark.column+1);

				}

				break;

			default:

				fprintf(stderr, "Internal error\n");

				break;

			}

			return 1;

		} else {

			event_type = event.type;

			if (!yaml_path_filter_event(path, parser, &event, mode)) {

				yaml_event_delete(&event);

			} else {

				if (use_flow_style) {

					switch (event.type) {

					case YAML_SEQUENCE_START_EVENT:

						event.data.sequence_start.style = YAML_FLOW_SEQUENCE_STYLE;

						break;

					case YAML_MAPPING_START_EVENT:

						event.data.mapping_start.style = YAML_FLOW_MAPPING_STYLE;

						break;

					default:

						break;

					}

				}

				if (prev_event_type == YAML_DOCUMENT_START_EVENT && event_type == YAML_DOCUMENT_END_EVENT) {

					yaml_event_t null_event= {0};

					yaml_scalar_event_initialize(&null_event, NULL, (yaml_char_t *)"!!null", (yaml_char_t *)"null", 4, 1, 0, YAML_ANY_SCALAR_STYLE);

					yaml_emitter_emit(emitter, &null_event);

				}

				prev_event_type = event_type;

				if (!yaml_emitter_emit(emitter, &event)) {

					switch (emitter->error)

					{

					case YAML_MEMORY_ERROR:

						fprintf(stderr, "Memory error: Not enough memory for emitting\n");

						break;

					case YAML_WRITER_ERROR:

						fprintf(stderr, "Writer error: %s\n", emitter->problem);

						break;

					case YAML_EMITTER_ERROR:

						fprintf(stderr, "Emitter error: %s\n", emitter->problem);

						break;

					default:

						fprintf(stderr, "Internal error\n");

						break;

					}

					return 2;

				}

			}

		}

	} while (event_type != YAML_STREAM_END_EVENT);

	return 0;

}

void help (void)

{

	printf("yamlp - filtering utility for YAML documents\n");

	printf("\n");

	printf("Usage: yamlp [-F] [-S] [-W <width>] [-f <file>] <path>\n");

	printf("       yamlp -h\n");

	printf("\n");

	printf("The tool will take the input YAML document from <stdin> or a <file> (-f option),\n");

	printf("and it will then return the portion of the document marked with the given <path>.\n");

	printf("\n");

	printf("Options:\n");

	printf("  -f	a filename to get the YAML document from,\n");

	printf("    	<stdin> will be used if omitted;\n");

	printf("\n");

	printf("  -F	forced 'flow' style for the output YAML document;\n");

	printf("\n");

	printf("  -h	help;\n");

	printf("\n");

	printf("  -S	'shallow' filter mode;\n");

	printf("\n");

	printf("  -W	line wrap width, no wrapping if omitted.\n");

	printf("\n");

}

int main(int argc, char *argv[])

{

	int flow = 0;

	char *file_name = NULL;

	char *path_string = NULL;

	int wrap = -1;

	yaml_path_filter_mode_t mode = YAML_PATH_FILTER_RETURN_ALL;

	int opt;

	while ((opt = getopt(argc, argv, ":f:W:vhSF")) != -1) {

		switch (opt) {

		case 'h':

			help();

			return 0;

			break;

		case 'F':

			flow = 1;

			break;

		case 'S':

			mode = YAML_PATH_FILTER_RETURN_SHALLOW;

			break;

		case 'W':

			wrap = strtol(optarg, NULL, 10);

			if (!wrap) {

				fprintf(stderr, "Invalid value for wrap width '%s'\n", optarg);

				return 1;

			}

			break;

		case 'f':

			file_name = optarg;

			break;

		case ':':

			fprintf(stderr, "Option needs a value\n");

			return 1;

			break;

		case '?':

			fprintf(stderr, "Unknown option '%c'\n", optopt);

			return 1;

			break;

		}

	}

	for (; optind < argc; optind++) {

		path_string = argv[optind];

	}

	FILE *file = NULL;

	if (file_name != NULL) {

		file = fopen(file_name, "r");

		if (file == NULL) {

			fprintf(stderr, "Unable to open file '%s' (%s)\n", file_name, strerror(errno));

			return 2;

		}

	}

	if (path_string == NULL || path_string[0] == 0) {

		fprintf(stderr, "Empty path\n");

		return 3;

	}

	yaml_path_t *path = yaml_path_create();

	if (yaml_path_parse(path, path_string)) {

		fprintf(stderr, "Invalid path '%s' (%s)\n", path_string, yaml_path_error_get(path)->message);

		return 3;

	};

	yaml_parser_t parser;

	yaml_emitter_t emitter;

	yaml_parser_initialize(&parser);

	yaml_parser_set_input_file(&parser, file != NULL ? file : stdin);

	yaml_emitter_initialize(&emitter);

	yaml_emitter_set_output_file(&emitter, stdout);

	yaml_emitter_set_width(&emitter, wrap);

	if (parse_and_emit(&parser, &emitter, path, mode, flow)) {

		return 4;

	}

	yaml_parser_delete(&parser);

	yaml_emitter_delete(&emitter);

	yaml_path_destroy(path);

	fclose(file);

	return 0;

}