/* See LICENSE file for copyright and license details. */

#define _POSIX_C_SOURCE 200809L

#include <libgen.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "decode.h"
#include "diff.h"
#include "util.h"

#ifndef VERSION
#define VERSION "0.1"
#endif

#ifndef DEFAULT_THRESH
#define DEFAULT_THRESH 8
#endif

static void
usage(void)
{
	fprintf(stderr,
	        "usage: sframe [-v] [-t threshold] [-f png|jpg]"
	        " [-o outdir] video [...]\n"
	        "\n"
	        "options:\n"
	        "  -t N   hash threshold 0-64"
	        " (default: %d, lower = stricter)\n"
	        "  -f fmt output format: png or jpg"
	        " (default: png)\n"
	        "  -o dir output directory"
	        " (default: ~/frames)\n"
	        "  -v     print version\n",
	        DEFAULT_THRESH);
	exit(1);
}

/*
 * Strip file extension and directory, return allocated
 * copy of the base name suitable for use as a directory
 * and filename prefix. Replaces spaces with underscores.
 */
static char *
video_name(const char *path)
{
	char *copy, *base, *dot, *name, *p;

	copy = estrdup(path);
	base = basename(copy);

	dot = strrchr(base, '.');
	if (dot)
		*dot = '\0';

	name = estrdup(base);
	free(copy);

	/* sanitize: replace spaces and slashes */
	for (p = name; *p; p++) {
		if (*p == ' ' || *p == '/')
			*p = '_';
	}

	return name;
}

static void
ts_string(double secs, char *buf, size_t len)
{
	int h, m, s, ms;

	if (secs < 0.0)
		secs = 0.0;

	h = (int)(secs / 3600.0);
	secs -= h * 3600.0;
	m = (int)(secs / 60.0);
	secs -= m * 60.0;
	s = (int)secs;
	ms = (int)((secs - s) * 1000.0);

	snprintf(buf, len, "%02d-%02d-%02d.%03d", h, m, s, ms);
}

static int
process_video(const char *path, const char *outdir,
              int threshold, const char *fmt)
{
	Decoder dec;
	AVFrame *frame;
	char *name;
	char dirpath[4096];
	char filepath[4096];
	char tsbuf[32];
	uint64_t prev_hash;
	uint64_t cur_hash;
	double ts;
	int dist;
	int saved;
	int total;
	int first;

	name = video_name(path);

	snprintf(dirpath, sizeof(dirpath), "%s/%s", outdir, name);
	if (mkdirp(dirpath) < 0)
		die("cannot create directory '%s':", dirpath);

	if (dec_open(&dec, path) < 0) {
		free(name);
		return -1;
	}

	frame = av_frame_alloc();
	if (!frame) {
		dec_close(&dec);
		free(name);
		die("cannot allocate frame");
	}

	fprintf(stderr, "processing: %s (%dx%d)\n",
	        path, dec.width, dec.height);
	fprintf(stderr, "output:     %s/\n", dirpath);
	fprintf(stderr, "threshold:  %d\n", threshold);

	saved = 0;
	total = 0;
	first = 1;
	prev_hash = 0;

	while (dec_read_frame(&dec, frame) == 0) {
		total++;

		cur_hash = diff_phash(frame, dec.sws_gray,
		                      dec.width, dec.height);

		if (!first) {
			dist = diff_hamming(prev_hash, cur_hash);
			if (dist <= threshold) {
				av_frame_unref(frame);
				continue;
			}
		}

		ts = dec_frame_time(&dec, frame);
		ts_string(ts, tsbuf, sizeof(tsbuf));

		snprintf(filepath, sizeof(filepath),
		         "%s/%s-%s.%s",
		         dirpath, name, tsbuf, fmt);

		if (diff_save_frame(frame, dec.sws_rgb,
		                    dec.width, dec.height,
		                    filepath, fmt) == 0) {
			saved++;
			if (saved % 50 == 0) {
				fprintf(stderr,
				        "\r  saved %d unique frames"
				        " (%d scanned)...",
				        saved, total);
			}
		}

		prev_hash = cur_hash;
		first = 0;
		av_frame_unref(frame);
	}

	fprintf(stderr,
	        "\r  done: %d unique frames from %d total\n",
	        saved, total);

	av_frame_free(&frame);
	dec_close(&dec);
	free(name);
	return 0;
}

int
main(int argc, char *argv[])
{
	const char *outdir;
	const char *fmt;
	char default_outdir[4096];
	const char *home;
	int threshold;
	int opt;
	int i;
	int ret;

	threshold = DEFAULT_THRESH;
	fmt = "png";
	outdir = NULL;

	while ((opt = getopt(argc, argv, "t:f:o:v")) != -1) {
		switch (opt) {
		case 't':
			threshold = atoi(optarg);
			if (threshold < 0 || threshold > 64)
				die("threshold must be 0-64");
			break;
		case 'f':
			if (strcmp(optarg, "png") != 0
			    && strcmp(optarg, "jpg") != 0
			    && strcmp(optarg, "jpeg") != 0)
				die("format must be png or jpg");
			fmt = optarg;
			break;
		case 'o':
			outdir = optarg;
			break;
		case 'v':
			fprintf(stdout, "sframe %s\n", VERSION);
			return 0;
		default:
			usage();
		}
	}

	if (optind >= argc)
		usage();

	/* default output: ~/frames */
	if (!outdir) {
		home = getenv("HOME");
		if (!home)
			die("HOME not set");
		snprintf(default_outdir, sizeof(default_outdir),
		         "%s/frames", home);
		outdir = default_outdir;
	}

	if (mkdirp(outdir) < 0)
		die("cannot create output directory '%s':", outdir);

	ret = 0;
	for (i = optind; i < argc; i++) {
		if (process_video(argv[i], outdir,
		                  threshold, fmt) < 0)
			ret = 1;
	}

	return ret;
}