/* 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 "etl_template.h"
#include "etl_variables.h"
#include "etl_version.h"
#include "etl_data.h"

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

static void
usage()
{
  fprintf(stderr, "usage: etl [-I dir] [-D name=val] <template> [data]\n");
  exit(1);
}

static void
set_var(const char *key, void *val, void *baton)
{
  etl_hash_set(baton, key, val);
}

int
main(int argc, char *argv[])
{
  etl_resolver_t *resolver = NULL;
  etl_array_t *search_path;
  etl_stream_t *out;
  etl_hash_t *environment;
  etl_template_t *tmpl = NULL;
  etl_error_t *err;
  int argsleft;
  int rv = 0;
  char opt;

  search_path = etl_array_create(10);

  environment = etl_hash_create();

  while ((opt = getopt(argc, argv, "D:I:v")) != -1)
    {
      switch (opt)
        {
          case 'D':
            {
              char *name, *tmp, *str, *buf = strdup(optarg);
              etl_variable_t *v;
                 
              name = strtok_r(buf, "=", &tmp);
              if (! name)
                usage();

              str = strtok_r(NULL, "=", &tmp);
              if (! str)
                usage();

              v = etl_variable_make_str(str);

              etl_hash_set(environment, name, v);

              free(buf);
            }
            break;

          case 'I':
            {
              etl_array_push(search_path, strdup(optarg));
            }
            break;

          case 'v':
            {
              printf("etl %s\n", ETL_VERSION_STRING);

              return EXIT_SUCCESS;
            }
            break;

          default:
            break;
        }
    }

  argsleft = argc - optind;

  if (argsleft != 1 && argsleft != 2)
    usage();

  err = etl_stream_stdout_open(&out);
  if (err)
    goto cleanup;

  err = etl_template_parse_file(&tmpl, argv[optind]);
  if (err)
    goto cleanup;

  resolver = etl_resolver_file_create(search_path);

  if (argsleft == 2)
    {
      etl_hash_t *ddl_env;

      err = etl_ddl_parse_file(&ddl_env,
                               resolver,
                               argv[optind + 1]);
      if (err)
        goto cleanup;

      etl_hash_traverse(ddl_env, set_var, environment);

      etl_hash_destroy(ddl_env, NULL, NULL);
    }

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

cleanup:

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

      etl_error_clear(err);

      rv = 1;
    }

  etl_resolver_destroy(resolver);

  etl_template_destroy(tmpl);

  etl_ddl_destroy(environment);

  etl_stream_destroy(out);

  return rv;
}