// Copyright (c) 1996 James Clark, 1999 Matthias Clasen
// See the file COPYING for copying permission.

// Need option registration method that allows derived class to change
// option names.

#ifdef __GNUG__
#pragma implementation
#endif

#include "splib.h"
#include "CmdLineApp.h"
#include "CmdLineAppMessages.h"
#include "MessageArg.h"
#include "ErrnoMessageArg.h"
#include "Options.h"
#include "xnew.h"
#include "macros.h"
#include "sptchar.h"
#include "MessageTable.h"
#include "CodingSystemKit.h"

#include "ConsoleOutput.h"

#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>

#ifdef SP_HAVE_LOCALE
#include <locale.h>
#endif
#ifdef SP_HAVE_SETMODE
#include <fcntl.h>
#include <io.h>
#endif

#include <sys/types.h>
#ifdef SP_INCLUDE_UNISTD_H
#include <unistd.h>
#endif
#ifdef SP_INCLUDE_IO_H
#include <io.h>
#endif

#ifdef _MSC_VER
#include <crtdbg.h>
#endif

#ifndef SP_DEFAULT_ENCODING
#ifdef WIN32
#define SP_DEFAULT_ENCODING SP_T("WINDOWS")
#else
#define SP_DEFAULT_ENCODING  SP_T("IS8859-1")
#endif
#endif /* not SP_DEFAULT_ENCODING */

#ifndef SP_MESSAGE_DOMAIN
#define SP_MESSAGE_DOMAIN ""
#endif /* not SP_MESSAGE_DOMAIN */

#ifndef SP_LOCALE_DIR
#define SP_LOCALE_DIR ""
#endif /* not SP_LOCALE_DIR */

#ifdef SP_NAMESPACE
namespace SP_NAMESPACE {
#endif

static const SP_TCHAR *progName = 0;

static FileOutputByteStream standardOutput(1, 0);
static FileOutputByteStream standardError(2, 0);

CmdLineApp::CmdLineApp(const char *requiredInternalCode)
: errorFile_(0),
  outputCodingSystem_(0),
  SP_REPORTER_CLASS(0),
  internalCharsetIsDocCharset_(1),
  codingSystem_(0),
  action_(normalAction)
{
  initCodingSystem(requiredInternalCode);
  setMessageStream(makeStdErr());
  if (internalCharsetIsDocCharset_) 
    registerOption('b', SP_T("bctf"), 
                   CmdLineAppMessages::name, CmdLineAppMessages::bHelp);
  else
    registerOption('b', SP_T("encoding"), 
                   CmdLineAppMessages::name, CmdLineAppMessages::eHelp);
  registerOption('f', SP_T("error-file"), 
                 CmdLineAppMessages::file, CmdLineAppMessages::fHelp);
  registerOption('v', SP_T("version"), CmdLineAppMessages::vHelp);
  registerOption('h', SP_T("help"), CmdLineAppMessages::hHelp);
  registerInfo(CmdLineAppMessages::usageStart, 1);
}

void CmdLineApp::resetCodingSystemKit()
{
  codingSystemKit_ = codingSystemKit_->copy();
}

void CmdLineApp::registerOption(AppChar c, const AppChar *name,
                                const MessageType1 &doc)
{
  registerOption(c, name, CmdLineAppMessages::noArg, doc);
}

void CmdLineApp::changeOptionRegistration(AppChar oldc, AppChar newc)
{
  for (size_t i = 0; i < opts_.size(); i++) {
    if (opts_[i].value == oldc) {
      opts_[i].value = newc;
#ifdef SP_HAVE_LOCALE
      char *savedLocale = strdup(setlocale(LC_CTYPE, NULL));
      setlocale(LC_CTYPE, "C");
#endif
      opts_[i].key = istalnum(newc) ? newc : 0;
#ifdef SP_HAVE_LOCALE
      setlocale(LC_CTYPE, savedLocale);
      if (savedLocale)
        free(savedLocale);
#endif
      return;
    }
  }
}

void CmdLineApp::registerOption(AppChar c, const AppChar *name,
				const MessageFragment &arg,
                                const MessageType1 &doc)
{
  // these four are used for signals from Options<>::get()
  ASSERT((c != '-') && (c != ':') && (c != '?') && (c != '=')); 
  LongOption<AppChar> opt;
  opt.value = c;
#ifdef SP_HAVE_LOCALE
  char *savedLocale = strdup(setlocale(LC_CTYPE, NULL));
  setlocale(LC_CTYPE, "C");
#endif
  opt.key = istalnum(c) ? c : 0;
#ifdef SP_HAVE_LOCALE
  setlocale(LC_CTYPE, savedLocale);
  if (savedLocale)
    free(savedLocale);
#endif
  opt.name = name;
  opt.hasArgument = (arg.module() != CmdLineAppMessages::noArg.module()
                    || arg.number() != CmdLineAppMessages::noArg.number());
  for (size_t i = 0; i < opts_.size(); i++) 
    if (opts_[i].value == c) {
      for (; i + 1 < opts_.size(); i++) {
        opts_[i] = opts_[i + 1]; 
        optArgs_[i] = optArgs_[i + 1];
        optDocs_[i] = optDocs_[i + 1];
      }
      opts_[i] = opt;
      optArgs_[i] = arg; 
      optDocs_[i] = doc;
      return;
    }
  opts_.push_back(opt);
  optArgs_.push_back(arg);
  optDocs_.push_back(doc);
}

void CmdLineApp::registerUsage(const MessageType1 &u)
{
  usages_.push_back(u);
}

void CmdLineApp::registerInfo(const MessageType1 &i, bool pre)
{
  if (pre)
    preInfos_.push_back(i);
  else
    infos_.push_back(i);
}

// Backward compability. Will not display argName.
void CmdLineApp::registerOption(AppChar c, const AppChar *argName)
{
  if (argName)
    registerOption(c, 0, CmdLineAppMessages::someArg,
		   CmdLineAppMessages::undocOption);
  else
    registerOption(c, 0, CmdLineAppMessages::undocOption);
}

void CmdLineApp::usage()
{
  const OutputCharStream::Newline nl = OutputCharStream::newline;
  // We use the default encoding for the help message, since this is consistent
  // with error messages and probably is what users want.
  Owner<OutputCharStream> stdOut(ConsoleOutput::makeOutputCharStream(1));
  if (!stdOut)
    stdOut = new EncodeOutputCharStream(&standardOutput, codingSystem());

  Vector<CopyOwner<MessageArg> > args(1);
  StringMessageArg arg(convertInput(progName ? progName : SP_T("program")));
  args[0] = arg.copy();
  if (usages_.size() == 0) 
    usages_.push_back(CmdLineAppMessages::defaultUsage);
  for (size_t i = 0; i < usages_.size(); i++) {
    StrOutputCharStream ostr;
    StringC tem;
    formatMessage(usages_[i], args, ostr, 1);
    ostr.extractString(tem); 
    Vector<CopyOwner<MessageArg> > args2(1);
    StringMessageArg arg2(tem);
    args2[0] = arg2.copy();
    formatMessage(i ? CmdLineAppMessages::usageCont 
		  : CmdLineAppMessages::usage,
		  args2, *stdOut, 1);
    *stdOut << nl;
  } 

  for (size_t i = 0; i < preInfos_.size(); i++) {
    formatMessage(preInfos_[i], args, *stdOut, 1);
    *stdOut << nl;
  }
  Vector<StringC> leftSide;
  size_t leftSize = 0;
  for (size_t i = 0; i < opts_.size(); i++) {
    leftSide.resize(leftSide.size() + 1);
    StringC& s = leftSide.back();
    static const AppChar* space2 = SP_T("  ");
    s += convertInput(space2);
    if (opts_[i].key) {
      static const AppChar* dash = SP_T("-");
      s += convertInput(dash);
      AppChar buf[2];
      buf[0] = opts_[i].key;
      buf[1] = SP_T('\0');
      s += convertInput(buf);
      if (opts_[i].name) {
	static const AppChar* commaSpace = SP_T(", ");
	s += convertInput(commaSpace);
      }
      else if (opts_[i].hasArgument) {
	buf[0] = ' ';
	s += convertInput(buf);
      }
    }
    if (opts_[i].name) {
      static const AppChar* dash2 = SP_T("--");
      s += convertInput(dash2);
      s += convertInput(opts_[i].name);
      if (opts_[i].hasArgument) {
	static const AppChar* equal = SP_T("=");
	s += convertInput(equal);
      }
    }
    if (opts_[i].hasArgument) {
      StringC tem;
      getMessageText(optArgs_[i], tem);
      s += tem;
    }
    if (s.size() > leftSize)
      leftSize = s.size();
  }
  leftSize += 2;
  for (size_t i = 0; i < opts_.size(); i++) {
    for (size_t j = leftSide[i].size(); j <= leftSize; j++)
      leftSide[i] += ' ';
    StrOutputCharStream ostr;
    Vector<CopyOwner<MessageArg> > args2(1);
    StringC t;
    if (!getMessageText(optArgs_[i], t))
      t.resize(0);
    StringMessageArg arg(t);
    args2[0] = arg.copy(); 
    formatMessage(optDocs_[i], args2, ostr, 1);
    StringC tem;
    ostr.extractString(tem);
    *stdOut << leftSide[i] << tem << nl;
  }
  for (size_t i = 0; i < infos_.size(); i++) {
    formatMessage(infos_[i], args, *stdOut, 1);
    *stdOut << nl;
  }
}

static
void ewrite(const char *s)
{
  int n = (int)strlen(s);
  while (n > 0) {
    int nw = write(2, s, n);
    if (nw < 0)
      break;
    n -= nw;
    s += nw;
  }
}

static
#ifdef SP_FANCY_NEW_HANDLER
int outOfMemory(size_t)
#else
void outOfMemory()
#endif
{
  ewrite("SP library: out of memory\n");
  exit(1);
#ifdef SP_FANCY_NEW_HANDLER
  return 0;
#endif  
}

int CmdLineApp::init(int, AppChar **argv)
{
#ifndef SP_ANSI_LIB
  set_new_handler(outOfMemory);
#endif
#ifdef SP_HAVE_LOCALE
  setlocale(LC_ALL, "");
#endif
#ifdef SP_HAVE_SETMODE
  _setmode(1, _O_BINARY);
  _setmode(2, _O_BINARY);
#endif
  progName = argv[0];
  if (progName)
    setProgramName(convertInput(progName));
  MessageTable::instance()->registerMessageDomain(libModule,
                                                  SP_MESSAGE_DOMAIN, 
                                                  SP_LOCALE_DIR);
  MessageTable::instance()->registerMessageDomain(appModule,
                                                  SP_MESSAGE_DOMAIN, 
                                                  SP_LOCALE_DIR);
  return 0;
}

int CmdLineApp::run(int argc, AppChar **argv)
{
#ifdef _MSC_VER
  _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF|_CRTDBG_LEAK_CHECK_DF);
#endif
#ifdef SP_ANSI_LIB
  try {
#endif
  int ret = init(argc, argv);
  if (ret)
    return ret;
  int firstArg;
  ret = processOptions(argc, argv, firstArg);
  if (ret)
    return ret;
  // We do this here, so that the -b option works even if it is present after
  // the -h option.
  if (action_ == usageAction) {
    usage();
    return 0;
  }
  ret = processArguments(argc - firstArg, argv + firstArg);
  progName = 0;
  return ret;
#ifdef SP_ANSI_LIB
  }
catch (
#ifndef SP_NO_STD_NAMESPACE
       std::
#endif
	    bad_alloc) {
#ifdef SP_FANCY_NEW_HANDLER
    outOfMemory(0);
#else
    outOfMemory();
#endif
  }
  return 1;
#endif /* SP_ANSI_LIB */
}    

int CmdLineApp::processOptions(int argc, AppChar **argv, int &nextArg)
{
  AppChar ostr[80];
  Options<AppChar> options(argc, argv, opts_);
  AppChar opt;
  while (options.get(opt)) {
    switch (opt) {
    case '-':
    case '?':
    case '=':
    case ':':
      if (options.opt() == 0) {
        size_t i;
        const AppChar *t;
        for (i = 0, t = &argv[options.ind() - 1][2]; i < 79; i++, t++) {
          if  ((*t == '=') || (*t == '\0'))
            break;
          ostr[i] = *t;
        }
        ostr[i] = '\0';
      } 
      else {
        ostr[0] = options.opt();
        ostr[1] = SP_T('\0');
      }
      message((opt == '-') ? CmdLineAppMessages::ambiguousOptionError
               : ((opt == '=') ? CmdLineAppMessages::erroneousOptionArgError
               : ((opt == ':') ? CmdLineAppMessages::missingOptionArgError
               : CmdLineAppMessages::invalidOptionError)),
	      StringMessageArg(convertInput(ostr)));
      message(CmdLineAppMessages::tryHelpOptionForInfo);
      return 1;
    default:
      processOption(opt, options.arg());
      break;
    }
  }
  nextArg = options.ind();
  if (errorFile_) {
    static FileOutputByteStream file;
    if (!file.open(errorFile_)) {
      message(CmdLineAppMessages::openFileError,
	      StringMessageArg(convertInput(errorFile_)),
	      ErrnoMessageArg(errno));
      return 1;
    }
    setMessageStream(new EncodeOutputCharStream(&file, codingSystem()));
  }
  if (!outputCodingSystem_)
    outputCodingSystem_ = codingSystem();
  return 0;
}

void CmdLineApp::processOption(AppChar opt, const AppChar *arg)
{
  switch (opt) {
  case 'b':
    outputCodingSystem_ = lookupCodingSystem(arg);
    if (!outputCodingSystem_)
      message(internalCharsetIsDocCharset_
	      ? CmdLineAppMessages::unknownBctf
	      : CmdLineAppMessages::unknownEncoding,
	      StringMessageArg(convertInput(arg)));
    break;
  case 'f':
    errorFile_ = arg;
    break;
  case 'v':
    // print the version number
    message(CmdLineAppMessages::versionInfo,
	    StringMessageArg(codingSystem()->convertIn(SP_PACKAGE)),
	    StringMessageArg(codingSystem()->convertIn(SP_VERSION)));
    break;
  case 'h':
    action_ = usageAction;
    break;
  default:
    CANNOT_HAPPEN();
  }
}

Boolean CmdLineApp::getMessageText(const MessageFragment &frag,
				   StringC &text)
{
  String<SP_TCHAR> str;
  if (!MessageTable::instance()->getText(frag, str))
    return 0;
#ifdef SP_WIDE_SYSTEM
  text.resize(str.size());
  for (size_t i = 0; i < str.size(); i++)
    text[i] = Char(str[i]);
#else
  str += 0;
  text = codingSystem()->convertIn(str.data());
#endif
  return 1;
}

Boolean CmdLineApp::stringMatches(const SP_TCHAR *s, const char *key)
{
  for (; *key != '\0'; s++, key++) {
    if (*s != tolower(*key) && *s != toupper(*key))
      return 0;
  }
  return *s == '\0';
}

void CmdLineApp::initCodingSystem(const char *requiredInternalCode)
{
  const char *name = requiredInternalCode;
#ifdef SP_MULTI_BYTE
  char buf[256];
  if (!name) {
    const SP_TCHAR *internalCode = tgetenv(SP_T("SP_SYSTEM_CHARSET"));
    if (internalCode) {
      buf[255] = '\0';
      for (size_t i = 0; i < 255; i++) {
	buf[i] = internalCode[i];
	if (buf[i] == '\0')
	  break;
      }
      name = buf;
    }
  }
  if (requiredInternalCode)
    internalCharsetIsDocCharset_ = 0;
  else {
    const SP_TCHAR *useInternal = tgetenv(SP_T("SP_CHARSET_FIXED"));
    if (useInternal
        && (stringMatches(useInternal, "YES")
	    || stringMatches(useInternal, "1")))
      internalCharsetIsDocCharset_ = 0;
  }
#endif /* SP_MULTI_BYTE */
  codingSystemKit_ = CodingSystemKit::make(name);
  const SP_TCHAR *codingName = tgetenv(internalCharsetIsDocCharset_
				       ? SP_T("SP_BCTF")
				       : SP_T("SP_ENCODING"));
  if (codingName)
    codingSystem_ = lookupCodingSystem(codingName);
#ifdef SP_MULTI_BYTE
  if (!codingSystem_ && !internalCharsetIsDocCharset_)
    codingSystem_ = lookupCodingSystem(SP_DEFAULT_ENCODING);
#endif
  if (!codingSystem_
#ifndef SP_WIDE_SYSTEM
      || codingSystem_->fixedBytesPerChar() > 1
#endif
    )
    codingSystem_ = codingSystemKit_->identityCodingSystem();
}

const CodingSystem *
CmdLineApp::lookupCodingSystem(const AppChar *codingName)
{
#define MAX_CS_NAME 50
  if (tcslen(codingName) < MAX_CS_NAME) {
    char buf[MAX_CS_NAME];
    int i;
    for (i = 0; codingName[i] != SP_T('\0'); i++) {
      SP_TUCHAR c = codingName[i];
#ifdef SP_WIDE_SYSTEM
      if (c > (unsigned char)-1)
	return 0;
#endif
      buf[i] = char(c);
    }
    buf[i] = '\0';
    return codingSystemKit_->makeCodingSystem(buf, internalCharsetIsDocCharset_);
  }
  return 0;
}

StringC CmdLineApp::convertInput(const SP_TCHAR *s)
{
#ifdef SP_WIDE_SYSTEM
  StringC str;
  for (size_t i = 0; i < tcslen(s); i++)
    str += Char(s[i]);
#else
  StringC str(codingSystem()->convertIn(s));
#endif
  for (size_t i = 0; i < str.size(); i++)
    if (str[i] == '\n')
      str[i] = '\r';
  return str;
}

OutputCharStream *CmdLineApp::makeStdErr()
{
  OutputCharStream *os = ConsoleOutput::makeOutputCharStream(2);
  if (os)
    return os;
  return new EncodeOutputCharStream(&standardError, codingSystem());
}

OutputCharStream *CmdLineApp::makeStdOut()
{
  OutputCharStream *os = ConsoleOutput::makeOutputCharStream(1);
  if (os)
    return os;
  return new EncodeOutputCharStream(&standardOutput, outputCodingSystem_);
}

const MessageType2 &CmdLineApp::openFileErrorMessage()
{
  return CmdLineAppMessages::openFileError;
}

const MessageType2 &CmdLineApp::closeFileErrorMessage()
{
  return CmdLineAppMessages::closeFileError;
}

#ifdef SP_NAMESPACE
}
#endif