/* Copyright 2005 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 "apr_template.h"

#include <apr_strings.h>

#include <stdlib.h>

#ifndef APR_ARRAY_PUSH
#define APR_ARRAY_PUSH(ary,type) (*((type *)apr_array_push(ary)))
#endif

static apr_template_variable_t *
make_int_array (int start, int end, apr_pool_t *pool)
{
  apr_template_variable_t *a = apr_template_make_array (end - start, pool);
  int i;

  for (i = start; i < end; ++i)
    {
      APR_ARRAY_PUSH (a->contents.a, apr_template_variable_t *)
        = apr_template_make_int (i, pool);
    }

  return a;
}

int
main (int argc, char *argv[])
{
  apr_bucket_alloc_t *alloc;
  apr_bucket_brigade *out;
  apr_hash_t *environment;
  apr_template_t *tmpl;
  apr_status_t apr_err;
  apr_pool_t *pool;

  apr_initialize ();

  atexit (apr_terminate);

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

  apr_pool_create (&pool, NULL);

  environment = apr_hash_make (pool);

  /* set up some variables so we can use them in the test templates */

  apr_hash_set (environment,
                "true",
                APR_HASH_KEY_STRING,
                apr_template_make_int (1, pool));

  apr_hash_set (environment,
                "false",
                APR_HASH_KEY_STRING,
                apr_template_make_int (0, pool));

  apr_hash_set (environment,
                "numbers",
                APR_HASH_KEY_STRING,
                make_int_array (0, 10, pool));

  {
    apr_template_variable_t *hash = apr_template_make_hash (pool);

    apr_hash_set (hash->contents.h,
                  "key",
                  APR_HASH_KEY_STRING,
                  apr_template_make_str ("value", pool));

    apr_hash_set (environment,
                  "hash",
                  APR_HASH_KEY_STRING,
                  hash);
  }

  alloc = apr_bucket_alloc_create (pool);

  out = apr_brigade_create (pool, alloc);

  apr_err = apr_template_parse_file (&tmpl, argv[1], pool);
  if (apr_err)
    goto cleanup;

  apr_err = apr_template_execute (tmpl, environment, out, pool);
  if (apr_err)
    goto cleanup;

  {
    apr_size_t nread, datalen;
    char *data, *buffer;
    apr_finfo_t finfo;
    apr_off_t outlen;
    apr_file_t *file;

    apr_err = apr_file_open (&file,
                             argv[2],
                             APR_READ,
                             APR_FPROT_OS_DEFAULT,
                             pool);
    if (apr_err)
      goto cleanup;

    apr_err = apr_file_info_get (&finfo, APR_FINFO_SIZE, file);
    if (apr_err)
      goto cleanup;

    buffer = apr_pcalloc (pool, finfo.size + 1);

    apr_err = apr_file_read_full (file, buffer, finfo.size, &nread);
    if (apr_err)
      goto cleanup;

    apr_err = apr_brigade_length (out, 1, &outlen);
    if (apr_err)
      goto cleanup;

    apr_err = apr_brigade_pflatten (out, &data, &datalen, pool);
    if (apr_err)
      goto cleanup;

    if (memcmp (buffer, data, datalen) != 0)
      {
        fprintf (stdout,
                 "error: output of %s differs in content from %s\n"
                 "       got      '%s'\n"
                 "       expected '%s'\n",
                 argv[1],
                 argv[2],
                 data,
                 buffer);
        return 1;
      }
  }

cleanup:

  if (apr_err)
    {
      char buffer[1024] = { 0 };

      fprintf (stdout, "error: %s\n", apr_strerror (apr_err,
                                                    buffer,
                                                    sizeof (buffer)));
      return 1;
    }

  apr_brigade_destroy (out);

  apr_bucket_alloc_destroy (alloc);

  apr_pool_destroy (pool);

  return 0;
}