/* Copyright 2005-2006 Garrett Rooney.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "etl_template.h"
#include "etl_data.h"

#include <stdio.h>
#include <unistd.h>
#include <sys/param.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>

int
main (int argc, char *argv[])
{
  char etl_path[PATH_MAX];
  char ddl_path[PATH_MAX];
  char out_path[PATH_MAX];
  const char *inc_path;
  etl_array_t *search_path;
  etl_resolver_t *resolver;
  etl_stream_t *out;
  etl_hash_t *environment;
  etl_template_t *tmpl;
  etl_error_t *err;

  if (argc != 2)
    {
      fprintf (stdout, "usage: compare <path>\n");
      return 1;
    }

  sprintf (etl_path, "%s.etl", argv[1]);
  sprintf (ddl_path, "%s.ddl", argv[1]);
  sprintf (out_path, "%s.out", argv[1]);

  inc_path = argv[1];

  search_path = etl_array_create (1);

  *strrchr(inc_path, '/') = '\0';

  etl_array_push (search_path, strdup(inc_path));

  resolver = etl_resolver_file_create (search_path);

  err = etl_ddl_parse_file (&environment,
                            resolver,
                            ddl_path);
  if (err)
    goto cleanup;

  err = etl_stream_file_open (&out, ".test.output",
                              etl_stream_open_read
                              | etl_stream_open_write
                              | etl_stream_open_create
                              | etl_stream_open_truncate);
  if (err)
    goto cleanup;

  err = etl_template_parse_file (&tmpl, etl_path);
  if (err)
    goto cleanup;

  err = etl_template_execute (tmpl, resolver, environment, out);
  if (err)
    goto cleanup;

  etl_stream_destroy (out);

  {
    size_t buflen, datalen;
    etl_stream_t *stream;
    char *data, *buffer;
    struct stat sb;
    int idx;

    if (stat (out_path, &sb) == -1)
      {
        err = etl_error_createf(ETL_EINVAL, "Couldn't stat '%s'", out_path);
        if (err)
          goto cleanup;
      }

    buflen = sb.st_size;

    buffer = calloc (1, buflen + 1);

    err = etl_stream_file_open (&stream, out_path, etl_stream_open_read);
    if (err)
      {
        free (buffer);
        etl_stream_destroy (stream);
        goto cleanup;
      }

    for (idx = 0; idx < sb.st_size; ++idx)
      {
        size_t one = 1;

        err = etl_stream_read (stream, buffer + idx, &one);
        if (err)
          {
            free (buffer);
            etl_stream_destroy (stream);
            goto cleanup;
          }
      }

    etl_stream_destroy (stream);

    if (stat (".test.output", &sb) == -1)
      {
        err = etl_error_createf(ETL_EINVAL, "Couldn't stat '%s'", out_path);
        if (err)
          {
            free (buffer);
            goto cleanup;
          }
      }

    datalen = sb.st_size;

    data = calloc (1, datalen + 1);

    err = etl_stream_file_open (&stream, ".test.output", etl_stream_open_read);
    if (err)
      {
        free (buffer);
        free (data);
        goto cleanup;
      }

    for (idx = 0; idx < sb.st_size; ++idx)
      {
        size_t one = 1;

        err = etl_stream_read (stream, data + idx, &one);
        if (err)
          {
            free (buffer);
            free (data);
            etl_stream_destroy (stream);
            goto cleanup; 
          }
      }

    etl_stream_destroy (stream);

    if (memcmp (buffer, data, datalen) != 0)
      {
        fprintf (stdout,
                 "error: output of %s differs in content from %s\n"
                 "       got      '%s'\n"
                 "       expected '%s'\n",
                 etl_path,
                 out_path,
                 data,
                 buffer);

        free (data);
        free (buffer);

        return 1;
      }

    free (data);
    free (buffer);
  }

cleanup:

  if (err)
    {
      fprintf (stdout,
               "error: %s\n"
               "       %d\n"
               "thrown from %s:%d\n",
               err->msg,
               err->err,
               err->file,
               err->line);

      return 1;
    }

  etl_resolver_destroy (resolver);

  etl_template_destroy (tmpl);

  etl_ddl_destroy (environment);

  unlink(".test.output");

  return 0;
}