#include <bits/pthreadtypes.h>
#include <inttypes.h>
#include <libavcodec/avcodec.h>
#include <libavfilter/avfilter.h>
#include <libavformat/avformat.h>
#include <libavutil/pixdesc.h>
#include <libswscale/swscale.h>
#include <stdio.h>
#include <stdlib.h>
#include <tuberia.h>
#include <unistd.h>

const char *optstring = "hi:o:s:T";

static void printhelp(const char *argv0)
{
	printf(
			"%s -i <input> -o <output> -s <size> [-T]\n"
			"%s -h\n"
			"\n"
			" -i input           the input file\n"
			" -o output          the output file\n"
			" -s WIDTHxHEIGHT    the size to scale the video\n"
			" -T                 don't use libtuberia\n"
			" -h                 print this help\n", argv0, argv0);
}

static void close_codec(AVCodecContext **ctx)
{
	avcodec_free_context(ctx);
}

static void close_input(AVFormatContext **ctx)
{
	avformat_close_input(ctx);
}

static int open_input(AVFormatContext **avformatin, AVCodecContext **avcodecin,
		const char *file)
{
	AVFormatContext *ctx = NULL;
	AVCodec *codec = NULL;
	int i = 0;

	if (avformatin == NULL || avcodecin == NULL || file == NULL || !file[0]) {
		return -1;
	}

	printf("Opening input file %s\n", file);
	if (avformat_open_input(&ctx, file, NULL, NULL)) {
		return -1;
	}
	printf("Parsing input file %s\n", file);
	if (avformat_find_stream_info(ctx, NULL) < 0) {
		close_input(&ctx);
		return -1;
	}

	for (i = 0; i < (int)ctx->nb_streams; i++) {
		if (ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
			codec = avcodec_find_decoder(ctx->streams[i]->codecpar->codec_id);
			if (codec == NULL) {
				fprintf(stderr, "Couldn't find decoder for codec id %d (%s)\n",
						ctx->streams[i]->codecpar->codec_id,
						avcodec_get_name(ctx->streams[i]->codecpar->codec_id));
				close_input(&ctx);
				return -1;
			}
			printf("Opening input codec %s (%d)\n", avcodec_get_name(codec->id),
					codec->id);
			*avcodecin = avcodec_alloc_context3(codec);
			avcodec_parameters_to_context(*avcodecin, ctx->streams[i]->codecpar);
			(*avcodecin)->time_base = ctx->streams[i]->time_base;
			if (avcodec_open2(*avcodecin, codec, NULL) < 0) {
				fprintf(stderr, "Couldn't open codec %d (%s)\n",
						ctx->streams[i]->codecpar->codec_id,
						avcodec_get_name(ctx->streams[i]->codecpar->codec_id));
				close_input(&ctx);
				close_codec(avcodecin);
				return -1;
			}
			break;
		}
	}

	*avformatin = ctx;

	return 0;
}

static void close_sws(struct SwsContext **ctx)
{
	sws_freeContext(*ctx);
	*ctx = NULL;
}

static void close_output(AVFormatContext **ctx)
{
	av_write_trailer(*ctx);
	avformat_flush(*ctx);
	avio_closep(&(*ctx)->pb);
	avformat_free_context(*ctx);
	*ctx = NULL;
}

static int open_output(AVFormatContext **avformatout,
		AVCodecContext **avcodecout, struct SwsContext **sws, const char *file,
		const AVFormatContext *input, int width, int height)
{
	AVFormatContext *ctx = NULL;
	int i = 0;
	const AVCodec *codec = NULL;
	const AVCodecParameters *codecparin = NULL;
	AVStream *stream = NULL;

	if (avformatout == NULL || avcodecout == NULL || input == NULL
			|| file == NULL || !file[0]) {
		return -1;
	}
	printf("Opening output file %s\n", file);
	if (avformat_alloc_output_context2(&ctx, NULL, NULL, file) < 0
			|| ctx == NULL) {
		return -1;
	}

	for (i = 0; i < (int)input->nb_streams; i++) {
		codecparin = input->streams[i]->codecpar;
		codec = avcodec_find_encoder(codecparin->codec_id);
		if (codec == NULL) {
			fprintf(stderr, "Couldn't find encoder for codec id %d (%s)\n",
				codecparin->codec_id, avcodec_get_name(codecparin->codec_id));
			close_output(&ctx);
			return -1;
		}
		printf("Opening output codec %s (%d)\n", avcodec_get_name(codec->id),
				codec->id);
		stream = avformat_new_stream(ctx, codec);
		avcodec_parameters_copy(stream->codecpar, codecparin);
		stream->time_base = input->streams[i]->time_base;
		if (stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
			stream->codecpar->width = width;
			stream->codecpar->height = height;
		}
		if (stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
			*avcodecout = avcodec_alloc_context3(codec);
			avcodec_parameters_to_context(*avcodecout, stream->codecpar);
			(*avcodecout)->time_base = stream->time_base;
			if (avcodec_open2(*avcodecout, codec, NULL) < 0) {
				fprintf(stderr, "Couldn't open codec %s (%d)\n",
						avcodec_get_name(codecparin->codec_id),
						codecparin->codec_id);
				close_output(&ctx);
				close_codec(avcodecout);
				return -1;
			}
			printf("Opening resize context %dx%d %s -> %dx%d %s\n",
						codecparin->width, codecparin->height,
						av_get_pix_fmt_name((enum AVPixelFormat)codecparin->format),
						stream->codecpar->width, stream->codecpar->height,
						av_get_pix_fmt_name((enum AVPixelFormat)stream->codecpar->format));
			*sws = sws_getContext(codecparin->width, codecparin->height,
					(enum AVPixelFormat)codecparin->format,
					stream->codecpar->width, stream->codecpar->height,
					(enum AVPixelFormat)stream->codecpar->format,
					SWS_GAUSS, NULL, NULL, NULL);
			if (*sws == NULL) {
				fprintf(stderr, "Couldn't open resize context %dx%d %s -> %dx%d %s\n",
						codecparin->width, codecparin->height,
						av_get_pix_fmt_name((enum AVPixelFormat)codecparin->format),
						stream->codecpar->width, stream->codecpar->height,
						av_get_pix_fmt_name((enum AVPixelFormat)stream->codecpar->format));
				close_output(&ctx);
				close_codec(avcodecout);
				close_sws(sws);
			}
		}
	}

	if (!(ctx->flags & AVFMT_NOFILE)) {
		int ret = avio_open(&ctx->pb, file, AVIO_FLAG_WRITE);
		if (ret < 0) {
			fprintf(stderr, "Couldn't create output file %s %s (%d)\n", file,
					av_err2str(ret), ret);
			close_output(&ctx);
			close_codec(avcodecout);
			close_sws(sws);
			return -1;
		}
	}
	if (avformat_write_header(ctx, NULL) < 0) {
		fprintf(stderr, "Couldn't write header to output file %s\n", file);
	}
	*avformatout = ctx;
	return 0;
}

static void do_tuberia(AVFormatContext *avformatin, AVCodecContext *avcodecin,
		AVFormatContext *avformatout, struct SwsContext *sws,
		AVCodecContext *avcodecout)
{
	//TODO
	(void)avformatin;
	(void)avcodecin;
	(void)avformatout;
	(void)avcodecout;
	(void)sws;
	printf("Starting to transcode with libtuberia\n");
	printf("Transcode with libtuberia finished\n");
}

static int decode_packet(AVCodecContext *ctx, AVPacket *packet, AVFrame *frame)
{
	int ret = 0;
	ret = avcodec_send_packet(ctx, packet);
	av_packet_unref(packet);
	if (!ret) {
		ret = avcodec_receive_frame(ctx, frame);
	} else {
		fprintf(stderr, "Couldn't decode video packet\n");
	}

	return ret;
}

static int scale_frame(struct SwsContext *sws, AVFrame *frame, AVFrame *scaled,
		int width, int height, enum AVPixelFormat pix_fmt)
{
	av_frame_copy_props(scaled, frame);
	scaled->width = width;
	scaled->height = height;
	scaled->format = pix_fmt;
	av_frame_get_buffer(scaled, 0);
	sws_scale(sws, (const uint8_t * const *)frame->data, frame->linesize,
			0, frame->height, scaled->data, scaled->linesize);
	av_frame_unref(frame);

	return 0;
}

static int encode_frame(AVCodecContext *ctx, AVFrame *frame, AVPacket *packet)
{
	int ret = 0;

	ret = avcodec_send_frame(ctx, frame);
	av_frame_unref(frame);
	if (!ret) {
		ret = avcodec_receive_packet(ctx, packet);
	} else {
		fprintf(stderr, "Couldn't encode video packet\n");
	}

	return ret;
}

static void do_no_tuberia(AVFormatContext *avformatin, AVCodecContext *avcodecin,
		AVFormatContext *avformatout, struct SwsContext *sws,
		AVCodecContext *avcodecout)
{
	AVPacket *packet = NULL;
	AVFrame *frame = NULL;
	AVFrame *scaled = NULL;
	int idx = 0;

	printf("Starting to transcode without libtuberia\n");

	packet = av_packet_alloc();
	frame = av_frame_alloc();
	scaled = av_frame_alloc();
	while (!av_read_frame(avformatin, packet)) {
		idx = packet->stream_index;
		if (avformatin->streams[idx]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
			if (decode_packet(avcodecin, packet, frame)) {
				continue;
			}
			scale_frame(sws, frame, scaled, avcodecout->width,
					avcodecout->height, avcodecout->pix_fmt);
			if (encode_frame(avcodecout, scaled, packet)) {
				continue;
			}
			packet->stream_index = idx;
		}
		av_packet_rescale_ts(packet, avformatin->streams[idx]->time_base,
				avformatout->streams[idx]->time_base);
		av_interleaved_write_frame(avformatout, packet);
	}
	av_packet_free(&packet);
	av_frame_free(&frame);
	av_frame_free(&scaled);

	printf("Transcode without libtuberia finished\n");
}

int main(int argc, char **argv)
{
	int c = 0;
	char *input = NULL;
	char *output = NULL;
	int width = 720;
	int height = 404;
	int notuberia = 0;
	AVFormatContext *avformatin = NULL;
	AVFormatContext *avformatout = NULL;
	AVCodecContext *avcodecin = NULL;
	AVCodecContext *avcodecout = NULL;
	struct SwsContext *sws = NULL;

	while ((c = getopt(argc, argv, optstring)) >= 0) {
		switch (c) {
			case 'h':
				printhelp(argv[0]);
				return 0;
				break;
			case 'i':
				input = optarg;
				break;
			case 'o':
				output = optarg;
				break;
			case 's':
				if (sscanf(optarg, "%dx%d", &width, &height) != 2) {
					fprintf(stderr, "Size parameter must be WxH, instead it is %s\n",
							optarg);
					return -1;
				}
				break;
			case 'T':
				notuberia = 1;
				break;
			case '?':
			default:
				fprintf(stderr, "Incorrect arguments. Run %s -h\n", argv[0]);
				return -1;
		}
	}
	if (input == NULL || !input[0]) {
		printhelp(argv[0]);
		return -1;
	}

	if (open_input(&avformatin, &avcodecin, input) < 0) {
		fprintf(stderr, "Couldn't open input %s\n", input);
		return -1;
	}
	if (open_output(&avformatout, &avcodecout, &sws, output, avformatin, width,
				height) < 0) {
		fprintf(stderr, "Couldn't initiate output %s\n", output);
		return -1;
	}

	if (notuberia) {
		do_no_tuberia(avformatin, avcodecin, avformatout, sws, avcodecout);
	} else {
		do_tuberia(avformatin, avcodecin, avformatout, sws, avcodecout);
	}

	close_input(&avformatin);
	close_output(&avformatout);
	close_codec(&avcodecin);
	close_codec(&avcodecout);
	close_sws(&sws);

	return 0;
}