//--------------------------------------------------------------
// find a file in parent directories
BOOL mgOSFindFile(
  mgString& location,
  const char* fileName)
{
  WCHAR* oldCWD = _wgetcwd(NULL, 0);
  if (oldCWD == NULL)
    return false;
  mgString cwd(oldCWD);

  while (true)
  {
    if (cwd.endsWith("\\"))
      location.format("%s%s", (const char*) cwd, fileName);
    else location.format("%s\\%s", (const char*) cwd, fileName);

    WCHAR* wideName;
    int wideLen;
    location.toWCHAR(wideName, wideLen);
    struct _stat filestat;
    BOOL found = 0 == _wstat(wideName, &filestat);
    delete wideName; wideName = NULL;

    if (found)
      return true;
    else
    {
      // remove last directory from cwd
      int slash = cwd.reverseFind(cwd.length(), '\\');
      if (slash != -1)
        cwd.deleteAt(slash, cwd.length()-slash);
      else return false;   // no more directories. file not found.
    }
  }
}

//-----------------------------------------------------------------------------
// set a variable
void SeaOfMemes::debugSetVariable(
  const char* varName,
  const char* value,
  mgString& reply) 
{
  if (m_world == NULL)
  {
    reply.format("cannot set %s", varName);
    return;
  }

  double len;
  if (1 != sscanf(value, "%lf", &len))
  {
    reply.format("invalid value %s", value);
    return;
  }
  // keep rotation times in range
  len = max(1, len);

  reply = "ok";

  if (_stricmp(varName, "planetDayLen") == 0)
    m_world->m_planetDayLen = len;
  else if (_stricmp(varName, "moonDayLen") == 0)
    m_world->m_moonDayLen = len;
  else if (_stricmp(varName, "ringDayLen") == 0)
    m_world->m_ringDayLen = len;
  else if (_stricmp(varName, "moonMonthLen") == 0)
    m_world->m_moonMonthLen = len;
  else if (_stricmp(varName, "beltMonthLen") == 0)
    m_world->m_beltMonthLen = len;
  
  else reply.format("cannot set %s" ,varName);
}

//--------------------------------------------------------------
// find a file in parent directories
BOOL mgOSFindFile(
  mgString& location,
  const char* fileName)
{
  char* oldCWD = getcwd(NULL, 0);
  if (oldCWD == NULL)
    return false;

  mgString cwd(oldCWD);
  while (true)
  {
    if (cwd.endsWith("/"))
      location.format("%s%s", (const char*) cwd, fileName);
    else location.format("%s/%s", (const char*) cwd, fileName);

    struct stat filestat;
    if (0 == stat(location, &filestat))
      return true;
    else
    {
      // remove last directory from cwd
      int slash = cwd.reverseFind(cwd.length(), '/');
      if (slash != -1)
        cwd.deleteAt(slash, cwd.length()-slash);
      else return false;  // no more directories. file not found.
    }
  }
}

//--------------------------------------------------------------------------
// return shader log error messages as a string
void mgLinuxGL33Support::getShaderLog(
  GLuint shader,
  mgString& log)
{
  GLint logLen, retLen;
  glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &logLen);
  char* logText = new char[logLen];
  glGetShaderInfoLog(shader, logLen, &retLen, logText);
  log.empty();
  log.write((const char*) logText, retLen);
  delete logText;
}

//--------------------------------------------------------------------------
// get shader log error messages as string
void GL21getShaderLog(
  GLuint shader,
  mgString& logStr)
{
  GLint logLen, retLen;
  glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &logLen);
  char* logText = new char[logLen];
  glGetShaderInfoLog(shader, logLen, &retLen, logText);
  logStr.empty();
  logStr.write(logText, retLen);
  delete logText;
}

//--------------------------------------------------------------
// check version of OpenGL available
BOOL mgLinuxGL33Support::checkVersion(
  int reqGLVersion,
  int reqShaderVersion,
  mgString& errorMsg)
{
  const char* glVersionStr = (const char*) glGetString(GL_VERSION);
  if (glVersionStr == NULL)
  {
    errorMsg = "cannot read OpenGL version";
    return false;
  }

  int major, minor, glVersion;
  if (2 != sscanf(glVersionStr, "%d.%d", &major, &minor))
  {
    errorMsg.format("cannot parse OpenGL version %s", (const char*) glVersionStr);
    return false;
  }
  // trim trailing zeros.  3.3 and 3.30 are the same
  while (minor%10 == 0)
    minor /= 10;

  glVersion = major*100 + minor;

  const char* shaderVersionStr = (const char*) glGetString(GL_SHADING_LANGUAGE_VERSION);
  if (shaderVersionStr == NULL)
  {
    errorMsg = "cannot read OpenGL Shader Language version";
    return false;
  }

  int shaderVersion;
  if (2 != sscanf(shaderVersionStr, "%d.%d", &major, &minor))
  {
    errorMsg.format("cannot parse OpenGL version %s", (const char*) shaderVersionStr);
    return false;
  }
  // trim trailing zeros.  3.3 and 3.30 are the same
  while (minor%10 == 0)
    minor /= 10;

  shaderVersion = major*100 + minor;

  if (glVersion < reqGLVersion || shaderVersion < reqShaderVersion)
  {
    errorMsg.format("App requested OpenGl %d.%d, shader %d.%d\nSystem has OpenGL %d.%d, shader %d.%d", 
      reqGLVersion/100, reqGLVersion%100, reqShaderVersion/100, reqShaderVersion%100,
      glVersion/100, glVersion%100, shaderVersion/100, shaderVersion%100);
    return false;
  }

  return true;
}

//-----------------------------------------------------------------------------
// return value of variable
void SeaOfMemes::debugGetVariable(
  const char* varName,
  mgString& value) 
{
  mgPoint3 eyePt;
  if (m_world == NULL)
  {
    value = "unknown";
    return;
  }

  m_world->getEyePt(eyePt);

  if (_stricmp(varName, "eyePt.x") == 0)
    value.format("%g", eyePt.x);
  else if (_stricmp(varName, "eyePt.y") == 0)
    value.format("%g", eyePt.y);
  else if (_stricmp(varName, "eyePt.z") == 0)
    value.format("%g", eyePt.z);

  else if (_stricmp(varName, "planetDayLen") == 0)
    value.format("%g", m_world->m_planetDayLen);
  else if (_stricmp(varName, "moonDayLen") == 0)
    value.format("%g", m_world->m_moonDayLen);
  else if (_stricmp(varName, "ringDayLen") == 0)
    value.format("%g", m_world->m_ringDayLen);
  else if (_stricmp(varName, "moonMonthLen") == 0)
    value.format("%g", m_world->m_moonMonthLen);
  else if (_stricmp(varName, "beltMonthLen") == 0)
    value.format("%g", m_world->m_beltMonthLen);

  else value = "unknown variable";
}

//--------------------------------------------------------------
// comma format speed
void SpeedUI::commaFormat(
  mgString& line,
  const char* suffix,
  int value)
{
  line.format("%d %s", value, (const char*) suffix);

  // add the commas
  int posn = line.find(0, ' ')-3;
  while (posn > 0)
  {
    line.insertAt(posn, ",", 1);
    posn -= 3;
  }
}

//--------------------------------------------------------------
// substitute vars into message and return
void mgErrorTable::unknownMsg(
  mgString& text,               // returned message text
  const char* msgId,
  const char* varNames,
  const char* varValues)
{
  // no error message, so format args
  text.format("Unknown error(%s)", (const char*) msgId);
  int namePosn = 0;
  int valuePosn = 0;

  mgString argName;
  mgString argValue;
  while (true)
  {
    namePosn = parseVar(argName, varNames, namePosn);
    valuePosn = parseVar(argValue, varValues, valuePosn);
    if (namePosn == -1 || valuePosn == -1)
      break;

    text += ", ";
    text += argName;
    text += "=\"";
    text += argValue;
    text += "\"";
  }
}

//--------------------------------------------------------------
// process input line
void mgDebugPane::processInput(
  const mgString& input)
{
  mgString verb;
  int posn = input.getToken(0, " *(=", verb);

  if (verb.equalsIgnoreCase("help"))
  {
    mgString helpText;
    m_debugApp->debugHelp(helpText);
    m_console->addLine(OUTPUT_COLOR, NULL, helpText);
  }
  else if (verb.equalsIgnoreCase("list"))
  {
    listVariables();
    listFunctions();
  }
  else
  {
    if (!parseGetVariable(input))
    {
      if (!parseSetVariable(input))
      {
        if (!parseCallFunction(input))
          m_console->addLine(ERROR_COLOR, NULL, "Unknown command.");
      }
    }
  }
}

//--------------------------------------------------------------
// set slashes appropriately for OS
void mgOSFixFileName(
  mgString& name)
{
  name.trim();

  // convert any backslashes to forward slashes
  mgString bs("/");
  char letter[MG_MAX_LETTER];
  int posn = 0;
  while (posn < name.length())
  {
    int next = name.nextLetter(posn, letter);
    if (strcmp(letter, "\\") == 0)
      next = name.setLetter(posn, bs);
    posn = next;
  }
}

//--------------------------------------------------------------
// get cursor X coordinate
int mgSimpleField::getCursorX(
  const mgString& displayStr)
{
  int cursorX = 0;
  int posn = m_cursorPosn - m_scrollPosn;
  
  // if cursor position within displayed text
  if (posn <= displayStr.length())
  {
    // measure string from scroll position up to cursor
    cursorX = m_font->stringWidth(displayStr, posn);
  }
  else
  {
    // measure string from scroll position, plus blanks to cursor position
    cursorX = m_font->stringWidth(displayStr, displayStr.length());
    cursorX += m_font->stringWidth(" ", 1) * (posn - displayStr.length());
  }
  
  return cursorX;
}

//--------------------------------------------------------------
// resolve possibly relative file name.  
void mgOSResolveRelativeName(
  const char* sourceFile,
  const char* relName,
  mgString& absName)
{
  mgString name(relName);
  mgOSFixFileName(name);

  // if relative name starts with /, we're done
  if (name.startsWith("/"))
  {
    absName = name;
    return;
  }

  // assume it's really relative.  strip last directory in source file
  absName = sourceFile;
  int lastSlash = absName.reverseFind(absName.length(), "/");
  if (lastSlash != -1)
    absName.deleteAt(lastSlash+1, absName.length()-(lastSlash+1));
  else absName.empty();  // source file has no dir
  
  absName += name;
}

//--------------------------------------------------------------
// parse a name or value off the strings
int mgErrorTable::parseVar(
  mgString& value,
  const char* argString,
  int posn)
{
  value.empty();
  while (true)
  {
    char c = argString[posn++];
    if (c == '\0')
      return -1;
    if (c == MG_ERROR_DELIM)
      return posn;

    value += c;
  }
}

//--------------------------------------------------------------
// write stats to debug
void ChunkWorld::debugStats(
  mgString& status)
{
  m_chunkLock->lock();

  int unloadedCount = 0;
  int inmemoryCount = 0;
  int indisplayCount = 0;
  int needsUpdateCount = 0;

  ChunkListNode* lruItem = m_LRUList.m_first;
  while (lruItem != NULL)
  {
    ChunkObj* oldest = lruItem->m_chunk;
    switch (oldest->m_status)
    {
      case CHUNK_UNLOADED:
        unloadedCount++;
        break;
      case CHUNK_INMEMORY:
        inmemoryCount++;
        break;
      case CHUNK_INDISPLAY:
        indisplayCount++;
        break;
      case CHUNK_NEEDSUPDATE:
        needsUpdateCount++;
        break;
    }

    lruItem = lruItem->m_next;
  }

  status.format("system memory = %gM (%d chunks), display memory = %gM (%d chunks), update = %d, LRU = %d chunks (%d unloaded)",
        m_systemMemUsed/(1024*1024.0), inmemoryCount,
        m_displayMemUsed/(1024*1024.0), indisplayCount,
        needsUpdateCount,
        m_LRUList.length(), unloadedCount); 

  m_chunkLock->unlock();
}

//--------------------------------------------------------------
// resolve possibly relative file name.  
void mgOSResolveRelativeName(
  const char* sourceName,
  const char* relName,
  mgString& absName)
{
  mgString name(relName);
  mgOSFixFileName(name);

  // if relative name starts with backslash, we're done
  if (name.startsWith("\\"))
  {
    absName = name;
    return;
  }

  // if relative name starts with X: (drive letter), we're done
  char letter[MG_MAX_LETTER];
  int posn = name.nextLetter(0, letter);
  if (posn < name.length())
  {
    posn = name.nextLetter(posn, letter);
    if (strcmp(letter, ":") == 0)
    {
      absName = name;
      return;
    }
  }

  // assume it's really relative.  strip last directory in source file
  mgString sourceFile(sourceName);
  int lastSlash = sourceFile.reverseFind(sourceFile.length(), '\\');
  if (lastSlash != -1)
    sourceFile.substring(absName, 0, lastSlash+1);
  else absName.empty();  // source file has no dir

  absName += name;
}

//-----------------------------------------------------------------------------
// report status for debug log
void Landscape::appDebugStats(
  mgString& status)
{
  status.format("max count = %d", m_maxCount);
}

//-----------------------------------------------------------------
// get font string
void mgTextBuffer::getFont(
  mgString& fontSpec)
{
  fontSpec.format("%s-%d%s%s", (const char*) m_fontFace, m_fontSize, 
    m_fontBold == mgTrue? "-b" : "", m_fontItalic == mgTrue ? "-i" : "");
}