/*
# This file is part of the Astrometry.net suite.
# Licensed under a 3-clause BSD style license - see LICENSE
*/
#include <string.h>
#include <math.h>
#include <assert.h>

#include "plotoutline.h"
#include "cairoutils.h"
#include "ioutils.h"
#include "log.h"
#include "errors.h"
#include "sip-utils.h"
#include "sip_qfits.h"
#include "starutil.h"

DEFINE_PLOTTER(outline);

plotoutline_t* plot_outline_get(plot_args_t* pargs) {
	return plotstuff_get_config(pargs, "outline");
}

void* plot_outline_init(plot_args_t* plotargs) {
	plotoutline_t* args = calloc(1, sizeof(plotoutline_t));
	args->stepsize = 10;
	return args;
}

static void walk_callback(const anwcs_t* wcs, double ix, double iy,
                          double ra, double dec, void* token) {
    dl* radecs = (dl*)token;
	dl_append(radecs, ra);
	dl_append(radecs, dec);
}

int plot_outline_plot(const char* command,
					cairo_t* cairo, plot_args_t* pargs, void* baton) {
	plotoutline_t* args = (plotoutline_t*)baton;
	dl* rd;
	int i;
    pl* lists;

	assert(args->stepsize > 0);
	assert(args->wcs);
	assert(pargs->wcs);

	plotstuff_builtin_apply(cairo, pargs);

	logverb("Plotting outline of WCS: image size is %g x %g\n",
			anwcs_imagew(args->wcs), anwcs_imageh(args->wcs));

    rd = dl_new(256);
	anwcs_walk_image_boundary(args->wcs, args->stepsize, walk_callback, rd);
	logverb("Outline: walked in %zu steps\n", dl_size(rd)/2);

    if (dl_size(rd) == 0) {
        printf("plot_outline: empty WCS outline.\n");
        anwcs_print(args->wcs, stdout);
        dl_free(rd);
        return 0;
    }

	// avoid special case when there is a break between
	// the beginning and end of the list.
	dl_append(rd, dl_get(rd, 0));
	dl_append(rd, dl_get(rd, 1));

    lists = anwcs_walk_outline(pargs->wcs, rd, args->fill);
    dl_free(rd);
    for (i=0; i<pl_size(lists); i++) {
        dl* xy = pl_get(lists, i);
        int j;
        for (j=0; j<dl_size(xy)/2; j++) {
            double x,y;
            x = dl_get(xy, j*2+0);
            y = dl_get(xy, j*2+1);
            if (j == 0) {
                cairo_move_to(cairo, x, y);
            } else {
                cairo_line_to(cairo, x, y);
            }
        }
        cairo_close_path(cairo);
		if (args->fill)
			cairo_fill(cairo);
		else
			cairo_stroke(cairo);
        dl_free(xy);
    }
    pl_free(lists);
	return 0;
}

int plot_outline_set_wcs_size(plotoutline_t* args, int W, int H) {
  if (!args->wcs) {
    ERROR("No WCS is currently set.");
    return -1;
  }
  anwcs_set_size(args->wcs, W, H);
  return 0;
}

int plot_outline_set_wcs_file(plotoutline_t* args, const char* filename, int ext) {
	anwcs_t* wcs = anwcs_open(filename, ext);
	if (!wcs) {
		ERROR("Failed to read WCS file \"%s\"", filename);
		return -1;
	}
	logverb("Read WCS file %s\n", filename);
	if (args->wcs)
		anwcs_free(args->wcs);
	args->wcs = wcs;
	//anwcs_print(args->wcs, stdout);
	return 0;
}

int plot_outline_set_wcs(plotoutline_t* args, sip_t* wcs) {
	if (args->wcs)
		anwcs_free(args->wcs);
	args->wcs = anwcs_new_sip(wcs);
	return 0;
}

int plot_outline_set_fill(plotoutline_t* args, anbool fill) {
	args->fill = fill;
	return 0;
}

int plot_outline_command(const char* cmd, const char* cmdargs,
					   plot_args_t* pargs, void* baton) {
	plotoutline_t* args = (plotoutline_t*)baton;
	if (streq(cmd, "outline_wcs")) {
		if (plot_outline_set_wcs_file(args, cmdargs, 0)) {
			return -1;
		}
	} else if (streq(cmd, "outline_fill")) {
		if (streq(cmdargs, "0"))
			args->fill = FALSE;
		else
			args->fill = TRUE;
	} else if (streq(cmd, "outline_step")) {
		args->stepsize = atof(cmdargs);
	} else {
		ERROR("Did not understand command \"%s\"", cmd);
		return -1;
	}
	return 0;
}

void plot_outline_free(plot_args_t* plotargs, void* baton) {
	plotoutline_t* args = (plotoutline_t*)baton;
	free(args);
}