/******************************************************************************
*
*   Copyright (C) 2000-2002, International Business Machines
*   Corporation and others.  All Rights Reserved.
*
*******************************************************************************
*   file name:  pkgdata.c
*   encoding:   ANSI X3.4 (1968)
*   tab size:   8 (not used)
*   indentation:4
*
*   created on: 2000may15
*   created by: Steven \u24C7 Loomis
*
*   This program packages the ICU data into different forms
*   (DLL, common data, etc.)
*/

#include <stdio.h>
#include <stdlib.h>
#include "unicode/utypes.h"
#include "unicode/putil.h"
#include "cmemory.h"
#include "cstring.h"
#include "filestrm.h"
#include "toolutil.h"
#include "unewdata.h"
#include "uoptions.h"

#if U_HAVE_POPEN
# include <unistd.h>
#endif

U_CDECL_BEGIN
#include "pkgtypes.h"
#include "makefile.h"
U_CDECL_END

static int executeMakefile(const UPKGOptions *o);
static void loadLists(UPKGOptions *o, UErrorCode *status);

/* always have this fcn, just might not do anything */
static void fillInMakefileFromICUConfig(UOption *option);

/* This sets the modes that are available */
static struct
{
    const char *name, *alt_name;
    UPKGMODE   *fcn;
    const char *desc;
} modes[] =
{
    { "files", 0, pkg_mode_files, "Uses raw data files (no effect). Installation copies all files to the target location." },
#ifdef WIN32
    { "dll",    "library", pkg_mode_windows,    "Generates one common data file and one shared library, <package>.dll"},
    { "common", "archive", pkg_mode_windows,    "Generates just the common file, <package>.dat"},
    { "static", "static",  pkg_mode_windows,    "Generates one statically linked library, " LIB_PREFIX "<package>" UDATA_LIB_SUFFIX }
#else /*#ifdef WIN32*/
#ifdef UDATA_SO_SUFFIX
    { "dll",    "library", pkg_mode_dll,    "Generates one shared library, <package>" UDATA_SO_SUFFIX },
#endif
    { "common", "archive", pkg_mode_common, "Generates one common data file, <package>.dat" },
    { "static", "static",  pkg_mode_static, "Generates one statically linked library, " LIB_PREFIX "<package>" UDATA_LIB_SUFFIX }
#endif /*#ifdef WIN32*/
};

static UOption options[]={
    /*00*/    UOPTION_DEF( "name",    'p', UOPT_REQUIRES_ARG),
    /*01*/    UOPTION_DEF( "bldopt",  'O', UOPT_REQUIRES_ARG), /* on Win32 it is release or debug */
    /*02*/    UOPTION_DEF( "mode",    'm', UOPT_REQUIRES_ARG),
    /*03*/    UOPTION_HELP_H,                                   /* -h */
    /*04*/    UOPTION_HELP_QUESTION_MARK,                       /* -? */
    /*05*/    UOPTION_VERBOSE,                                  /* -v */
    /*06*/    UOPTION_COPYRIGHT,                                /* -c */
    /*07*/    UOPTION_DEF( "comment", 'C', UOPT_REQUIRES_ARG),
    /*08*/    UOPTION_DESTDIR,                                  /* -d */
    /*09*/    UOPTION_DEF( "clean",   'k', UOPT_NO_ARG),
    /*10*/    UOPTION_DEF( "nooutput",'n', UOPT_NO_ARG),
    /*11*/    UOPTION_DEF( "rebuild", 'F', UOPT_NO_ARG),
    /*12*/    UOPTION_DEF( "tempdir", 'T', UOPT_REQUIRES_ARG),
    /*13*/    UOPTION_DEF( "install", 'I', UOPT_REQUIRES_ARG),
    /*14*/    UOPTION_SOURCEDIR ,
    /*15*/    UOPTION_DEF( "entrypoint", 'e', UOPT_REQUIRES_ARG),
    /*16*/    UOPTION_DEF( "revision", 'r', UOPT_REQUIRES_ARG),
    /*17*/    UOPTION_DEF( 0, 'M', UOPT_REQUIRES_ARG),
    /*18*/    UOPTION_DEF( "force-prefix", 'f', UOPT_NO_ARG)
};

const char options_help[][160]={
    "Set the data name",
#ifdef WIN32
    "R:icupath for release version or D:icupath for debug version, where icupath is the directory where ICU is located",
#else
    "Specify options for the builder. (Autdetected if icu-config is available)",
#endif
    "Specify the mode of building (see below; default: common)",
    "This usage text",
    "This usage text",
    "Make the output verbose",
    "Use the standard ICU copyright",
    "Use a custom comment (instead of the copyright)",
    "Specify the destination directory for files",
    "Clean out generated & temporary files",
    "Suppress output of data, just list files to be created",
    "Force rebuilding of all data",
    "Specify temporary dir (default: output dir)",
    "Install the data (specify target)",
    "Specify a custom source directory",
    "Specify a custom entrypoint name (default: short name)",
    "Specify a version when packaging in DLL or static mode",
    "Pass the next argument to make(1)",
    "Add package to all file names if not present"
};

const char  *progname = "PKGDATA";

int
main(int argc, char* argv[]) {
    FileStream  *out;
    UPKGOptions  o;
    CharList    *tail;
    UBool        needsHelp = FALSE;
    UErrorCode   status = U_ZERO_ERROR;
    char         tmp[1024];
    int32_t i;

    U_MAIN_INIT_ARGS(argc, argv);

    progname = argv[0];

    options[2].value = "common";
    options[17].value = "";

    /* read command line options */
    argc=u_parseArgs(argc, argv, sizeof(options)/sizeof(options[0]), options);

    /* error handling, printing usage message */
    /* I've decided to simply print an error and quit. This tool has too
    many options to just display them all of the time. */

    if(options[3].doesOccur || options[4].doesOccur) {
        needsHelp = TRUE;
    }
    else {
        if(!needsHelp && argc<0) {
            fprintf(stderr,
                "%s: error in command line argument \"%s\"\n",
                progname,
                argv[-argc]);
            fprintf(stderr, "Run '%s --help' for help.\n", progname);
            return 1;
        }

        if(!options[1].doesOccur) {
          /* Try to fill in from icu-config or equivalent */
          fillInMakefileFromICUConfig(&options[1]);
        }
        
        if(!options[1].doesOccur) {
          fprintf(stderr, " required parameter is missing: -O is required \n");
          fprintf(stderr, "Run '%s --help' for help.\n", progname);
          return 1;
        }

        if(!options[0].doesOccur) /* -O we already have - don't report it. */
        {
          fprintf(stderr, " required parameter -p is missing \n");
          fprintf(stderr, "Run '%s --help' for help.\n", progname);
          return 1;
        }

        if(argc == 1) {
            fprintf(stderr,
                "No input files specified.\n"
                "Run '%s --help' for help.\n", progname);
            return 1;
        }
    }   /* end !needsHelp */

    if(argc<0 || needsHelp  ) {
        fprintf(stderr,
            "usage: %s [-options] [-] [packageFile] \n"
            "\tProduce packaged ICU data from the given list(s) of files.\n"
            "\t'-' by itself means to read from stdin.\n"
            "\tpackageFile is a text file containing the list of files to package.\n",
            progname);

        fprintf(stderr, "\n options:\n");
        for(i=0;i<(sizeof(options)/sizeof(options[0]));i++) {
            fprintf(stderr, "%-5s -%c %s%-10s  %s\n",
                (i<2?"[REQ]":""),
                options[i].shortName,
                options[i].longName ? "or --" : "     ",
                options[i].longName ? options[i].longName : "",
                options_help[i]);
        }

        fprintf(stderr, "modes: (-m option)\n");
        for(i=0;i<(sizeof(modes)/sizeof(modes[0]));i++) {
            fprintf(stderr, "   %-9s ", modes[i].name);
            if (modes[i].alt_name) {
                fprintf(stderr, "/ %-9s", modes[i].alt_name);
            } else {
                fprintf(stderr, "           ");
            }
            fprintf(stderr, "  %s\n", modes[i].desc);
        }
        return 1;
    }

    /* OK, fill in the options struct */
    uprv_memset(&o, 0, sizeof(o));

    o.mode      = options[2].value;
    o.version   = options[16].doesOccur ? options[16].value : 0;
    o.makeArgs  = options[17].value;

    o.fcn = NULL;

    for(i=0;i<sizeof(modes)/sizeof(modes[0]);i++) {
        if(!uprv_strcmp(modes[i].name, o.mode)) {
            o.fcn = modes[i].fcn;
            break;
        } else if (modes[i].alt_name && !uprv_strcmp(modes[i].alt_name, o.mode)) {
            o.mode = modes[i].name;
            o.fcn = modes[i].fcn;
            break;
        }
    }

    if(o.fcn == NULL) {
        fprintf(stderr, "Error: invalid mode '%s' specified. Run '%s --help' to list valid modes.\n", o.mode, progname);
        return 1;
    }

    o.shortName = options[0].value;
    /**/ {
        int len = uprv_strlen(o.shortName);
        char *csname, *cp;
        const char *sp;

        cp = csname = (char *) uprv_malloc((len + 1 + 1) * sizeof(*o.cShortName));
        if (*(sp = o.shortName)) {
            *cp++ = isalpha(*sp) ? * sp : '_';
            for (++sp; *sp; ++sp) {
                *cp++ = isalnum(*sp) ? *sp : '_';
            }
        }
        *cp = 0;

        o.cShortName = csname;
    }

#ifdef WIN32 /* format is R:pathtoICU or D:pathtoICU */
    {
        char *pathstuff = (char *)options[1].value;
        if(options[1].value[uprv_strlen(options[1].value)-1] == '\\') {
            pathstuff[uprv_strlen(options[1].value)-1] = '\0';
        }
        if(*pathstuff == 'R' || *pathstuff == 'D') {
            o.options = pathstuff;
            pathstuff++;
            if(*pathstuff == ':') {
                *pathstuff = '\0';
                pathstuff++;
            } else {
                fprintf(stderr, "Error: invalid windows build mode, should be R (release) or D (debug).\n", o.mode, progname);
                return 1;
            }
        } else {
            fprintf(stderr, "Error: invalid windows build mode, should be R (release) or D (debug).\n", o.mode, progname);
            return 1;
        }
        o.icuroot = pathstuff;
    }
#else /* on UNIX, we'll just include the file... */
    o.options   = options[1].value;
#endif
    o.verbose   = options[5].doesOccur;
    if(options[6].doesOccur) {
        o.comment = U_COPYRIGHT_STRING;
    } else if (options[7].doesOccur) {
        o.comment = options[7].value;
    }

    if( options[8].doesOccur ) {
        o.targetDir = options[8].value;
    } else {
        o.targetDir = ".";  /* cwd */
    }

    o.clean     = options[9].doesOccur;
    o.nooutput  = options[10].doesOccur;
    o.rebuild   = options[11].doesOccur;

    if( options[12].doesOccur ) {
        o.tmpDir    = options[12].value;
    } else {
        o.tmpDir    = o.targetDir;
    }

    if( options[13].doesOccur ) {
        o.install  = options[13].value;
    }

    if( options[14].doesOccur ) {
        o.srcDir   = options[14].value;
    } else {
        o.srcDir   = ".";
    }

    if( options[15].doesOccur ) {
        o.entryName = options[15].value;
    } else {
        o.entryName = o.cShortName;
    }

    /* OK options are set up. Now the file lists. */
    tail = NULL;
    for( i=1; i<argc; i++) {
        if ( !uprv_strcmp(argv[i] , "-") ) {
            /* stdin */
            if( o.hadStdin == TRUE ) {
                fprintf(stderr, "Error: can't specify '-' twice!\n"
                    "Run '%s --help' for help.\n", progname);
                return 1;
            }
            o.hadStdin = TRUE;
        }

        o.fileListFiles = pkg_appendToList(o.fileListFiles, &tail, uprv_strdup(argv[i]));
    }

    /* load the files */
    loadLists(&o, &status);
    if( U_FAILURE(status) ) {
        fprintf(stderr, "error loading input file lists: %s\n", u_errorName(status));
        return 2;
    }

    /* Makefile pathname */
    uprv_strcpy(tmp, o.tmpDir);
    uprv_strcat(tmp, U_FILE_SEP_STRING);
    uprv_strcat(tmp, o.shortName);
    uprv_strcat(tmp, "_");
    uprv_strcat(tmp, o.mode);
    uprv_strcat(tmp, ".mak");  /* MAY NEED TO CHANGE PER PLATFORM */

    o.makeFile = uprv_strdup(tmp);

    out = T_FileStream_open(o.makeFile, "w");
    if (out) {
        pkg_mak_writeHeader(out, &o); /* need to take status */
        o.fcn(&o, out, &status);
        pkg_mak_writeFooter(out, &o);
        T_FileStream_close(out);
    } else {
        fprintf(stderr, "warning: couldn't create %s, will use existing file if any\n", o.makeFile);
        /*status = U_FILE_ACCESS_ERROR;*/
    }

    if(U_FAILURE(status)) {
        fprintf(stderr, "Error creating makefile [%s]: %s\n", o.mode,
            u_errorName(status));
        return 1;
    }

    if(o.nooutput == TRUE) {
        return 0; /* nothing to do. */
    }

    return executeMakefile(&o);
}

/* POSIX - execute makefile */
static int executeMakefile(const UPKGOptions *o)
{
    char cmd[1024];
    /*char pwd[1024];*/
    const char *make;
    int rc;

    make = getenv("MAKE");

    if(!make || !make[0]) {
        make = U_MAKE;
    }

    /*getcwd(pwd, 1024);*/
#ifdef WIN32
    sprintf(cmd, "%s %s%s -f \"%s\" %s %s %s %s",
        make,
        o->install ? "INSTALLTO=" : "",
        o->install ? o->install    : "",
        o->makeFile,
        o->clean   ? "clean"      : "",
        o->rebuild ? "rebuild"    : "",
        o->install ? "install"    : "",
        o->makeArgs);
#elif OS400
    sprintf(cmd, "CALL GNU/GMAKE PARM(%s%s%s '-f' '%s' %s %s %s %s)",
        o->install ? "'INSTALLTO=" : "",
        o->install ? o->install    : "",
        o->install ? "'"           : "",
        o->makeFile,
        o->clean   ? "'clean'"     : "",
        o->rebuild ? "'rebuild'"   : "",
        o->install ? "'install'"   : "",
        o->makeArgs);
#else
    sprintf(cmd, "%s %s%s -f %s %s %s %s %s",
        make,
        o->install ? "INSTALLTO=" : "",
        o->install ? o->install    : "",
        o->makeFile,
        o->clean   ? "clean"      : "",
        o->rebuild ? "rebuild"    : "",
        o->install ? "install"    : "",
        o->makeArgs);
#endif
    if(o->verbose) {
        puts(cmd);
    }

    rc = system(cmd);

    if(rc < 0) {
        fprintf(stderr, "# Failed, rc=%d\n", rc);
    }

    return rc < 128 ? rc : (rc >> 8);
}


static void loadLists(UPKGOptions *o, UErrorCode *status)
{
  CharList   *l, *tail = NULL, *tail2 = NULL;
  FileStream *in;
  char        line[16384];
  char       *linePtr, *lineNext;
  const uint32_t   lineMax = 16300;
  char        tmp[1024], tmp2[1024];
  char        pkgPrefix[1024];
  int32_t     pkgPrefixLen;
  const char *baseName;
  char       *s;
  int32_t     ln;
  UBool       fixPrefix;
  
  
  fixPrefix = options[18].doesOccur;
  
  strcpy(pkgPrefix, o->shortName);
  strcat(pkgPrefix, "_");
  pkgPrefixLen=uprv_strlen(pkgPrefix);
  for(l = o->fileListFiles; l; l = l->next) {
    if(o->verbose) {
      fprintf(stdout, "# Reading %s..\n", l->str);
    }
    /* TODO: stdin */
    in = T_FileStream_open(l->str, "r");

    if(!in) {
      fprintf(stderr, "Error opening <%s>.\n", l->str);
      *status = U_FILE_ACCESS_ERROR;
      return;
    }

    ln = 0;

    while(T_FileStream_readLine(in, line, sizeof(line))!=NULL) {
      ln++;
      if(uprv_strlen(line)>lineMax) {
        fprintf(stderr, "%s:%d - line too long (over %d chars)\n", l->str, ln, lineMax);
        exit(1);
      }
      /* remove trailing newline characters */
      s=line;
      while(*s!=0) {
        if(*s=='\r' || *s=='\n') {
          *s=0;
          break;
        }
        ++s;
      }
      if((*line == 0) || (*line == '#')) {
        continue; /* comment or empty line */
      }

      /* Now, process the line */
      linePtr = line;
      lineNext = NULL;

      while(linePtr && *linePtr) {
        while(*linePtr == ' ') {
          linePtr++;
        }
        /* Find the next */
        if(linePtr[0] == '"')
          {
            lineNext = uprv_strchr(linePtr+1, '"');
            if(lineNext == NULL) {
              fprintf(stderr, "%s:%d - missing trailing double quote (\")\n",
                      l->str, ln);
              exit(1);
            } else {
              lineNext++;
              if(*lineNext) {
                if(*lineNext != ' ') {
                  fprintf(stderr, "%s:%d - malformed quoted line at position %d, expected ' ' got '%c'\n",
                          l->str, ln,  lineNext-line, (*lineNext)?*lineNext:'0');
                  exit(1);
                }
                *lineNext = 0;
                lineNext++;
              }
            }
          } else {
            lineNext = uprv_strchr(linePtr, ' ');
            if(lineNext) {
              *lineNext = 0; /* terminate at space */
              lineNext++;
            }
          }

        /* add the file */
        s = (char*)getLongPathname(linePtr);

        baseName = findBasename(s);
                    
        if(s != baseName) {
          /* s was something 'long' with a path */
          if(fixPrefix && uprv_strncmp(pkgPrefix, baseName, pkgPrefixLen)) {
            /* path don't have the prefix, add package prefix to short and longname */
            uprv_strcpy(tmp, pkgPrefix);
            uprv_strcpy(tmp+pkgPrefixLen, baseName);
                          
            uprv_strncpy(tmp2, s, uprv_strlen(s)-uprv_strlen(baseName));  /* should be:   dirpath only, ending in sep */
            tmp2[uprv_strlen(s)-uprv_strlen(baseName)]=0;
            uprv_strcat(tmp2, pkgPrefix);
            uprv_strcat(tmp2, baseName);
                          
            o->files = pkg_appendToList(o->files, &tail, uprv_strdup(tmp));
            o->filePaths = pkg_appendToList(o->filePaths, &tail2, uprv_strdup(tmp2));
          } else {
            /* paths already have the prefix */
            o->files = pkg_appendToList(o->files, &tail, uprv_strdup(baseName));
            o->filePaths = pkg_appendToList(o->filePaths, &tail2, uprv_strdup(s));
          }

        } else { /* s was just a basename, we want to prepend source dir*/
          /* check for prefix of package */
          uprv_strcpy(tmp, o->srcDir);
          uprv_strcat(tmp, o->srcDir[uprv_strlen(o->srcDir)-1]==U_FILE_SEP_CHAR?"":U_FILE_SEP_STRING);

          if(fixPrefix && strncmp(pkgPrefix,s, pkgPrefixLen)) {
            /* didn't have the prefix - add it */
            uprv_strcat(tmp, pkgPrefix);
            /* make up a new basename */
            uprv_strcpy(tmp2, pkgPrefix);
            uprv_strcat(tmp2, s);
            o->files = pkg_appendToList(o->files, &tail, uprv_strdup(tmp2));
          } else {
            o->files = pkg_appendToList(o->files, &tail, uprv_strdup(baseName));
          }
          uprv_strcat(tmp, s);
          o->filePaths = pkg_appendToList(o->filePaths, &tail2, uprv_strdup(tmp));
        }
        linePtr = lineNext;
      }
    }
    T_FileStream_close(in);
  }
}

/* Try calling icu-config directly to get information */
void fillInMakefileFromICUConfig(UOption *option)
{
#if U_HAVE_POPEN
  FILE *p;
  size_t n;
  static char buf[512] = "";
  static const char cmd[] = "icu-config --incfile";

  if(options[5].doesOccur)
  {
    /* informational */
    fprintf(stderr, "%s: No -O option found, trying '%s'.\n", progname, cmd);
  }

  p = popen(cmd, "r");

  if(p == NULL)
  {
    fprintf(stderr, "%s: icu-config: No icu-config found. (fix PATH or use -O option)\n", progname);
    return;
  }
  
  n = fread(buf, 1, 511, p);

  pclose(p);

  if(n<=0)
  {
    fprintf(stderr,"%s: icu-config: Could not read from icu-config. (fix PATH or use -O option)\n", progname);
    return;
  }

  if(buf[strlen(buf)-1]=='\n')
  {
    buf[strlen(buf)-1]=0;
  }
  
  if(buf[0] == 0)
  {
    fprintf(stderr, "%s: icu-config: invalid response from icu-config (fix PATH or use -O option)\n", progname);
    return;
  }

  if(options[5].doesOccur)
  {
    /* informational */
    fprintf(stderr, "%s: icu-config: using '-O %s'\n", progname, buf);
  }
  option->value = buf;
  option->doesOccur = TRUE;
#else  /* ! U_HAVE_POPEN */

  /* no popen available */
  /* Put other OS specific ways to search for the Makefile.inc type 
     information or else fail.. */

#endif
}
