#include "ttokenizer.h"

#include <qstring></qstring>

namespace TSyntax {

int Token::getIntValue() const {

  return QString::fromStdString(getText()).toInt();

}

double Token::getDoubleValue() const {

  return QString::fromStdString(getText()).toDouble();

}

//===================================================================

Tokenizer::Tokenizer() : m_buffer(), m_index(0) {}

//-------------------------------------------------------------------

Tokenizer::Tokenizer(std::string buffer) : m_buffer(), m_index(0) {

  setBuffer(buffer);

}

//===================================================================

Tokenizer::~Tokenizer() {}

//-------------------------------------------------------------------

void Tokenizer::setBuffer(std::string buffer) {

  m_buffer = buffer + '\0';

  m_index  = 0;

  m_tokens.clear();

  bool stringBlock = false;

  int i         = 0;

  const char *s = &m_buffer[0];

  for (;;) {

    while (isascii(s[i]) && isspace(s[i])) i++;

    int j = i;

    if (s[i] == '\0') {

      m_tokens.push_back(Token("", Token::Eos, j));

      break;

    }

    if (s[i] == '"') {

      stringBlock = !stringBlock;

      m_tokens.push_back(Token("\"", Token::Punct, j));

      ++i;

      continue;

    }

    std::string token;

    if (stringBlock) {

      // string block - read mercilessly until either another '"' or EOS

      token = std::string(1, s[i++]);

      while (s[i] != '"' && s[i] != '\0') token.append(1, s[i++]);

      m_tokens.push_back(Token(token, Token::Ident, j));

    } else if (isascii(s[i]) && isalpha(s[i]) || s[i] == '_') {

      // ident

      token = std::string(1, s[i++]);

      while (isascii(s[i]) && (isalpha(s[i]) || s[i] == '_' || isdigit(s[i])))

        token.append(1, s[i++]);

      m_tokens.push_back(Token(token, Token::Ident, j));

    } else if (isascii(s[i]) && isdigit(s[i]) || s[i] == '.') {

      // number

      while (isascii(s[i]) && isdigit(s[i])) token.append(1, s[i++]);

      if (s[i] == '.') {

        token.append(1, s[i++]);

        while (isascii(s[i]) && isdigit(s[i])) token.append(1, s[i++]);

        if ((s[i] == 'e' || s[i] == 'E') &&

            (isascii(s[i + 1]) && isdigit(s[i + 1]) ||

             (s[i + 1] == '-' || s[i + 1] == '+') && isascii(s[i + 2]) &&

                 isdigit(s[i + 2]))) {

          token.append(1, s[i++]);

          if (s[i] == '-' || s[i] == '+') token.append(1, s[i++]);

          while (isascii(s[i]) && isdigit(s[i])) token.append(1, s[i++]);

        }

      }

      m_tokens.push_back(Token(token, Token::Number, j));

    } else {

      // punct.

      if (s[i + 1] != '\0') {

        token = std::string(s + i, 2);

        const std::string ss[] = {"==", "!=", ">=", "<=", "||", "&&"};

        const int m = tArrayCount(ss);

        if (std::find(ss, ss + m, token) != ss + m)

          i += 2;

        else

          token = std::string(1, s[i++]);

      } else

        token = std::string(1, s[i++]);

      m_tokens.push_back(Token(token, Token::Punct, j));

    }

  }

}

//-------------------------------------------------------------------

int Tokenizer::getTokenCount() const { return m_tokens.size(); }

//-------------------------------------------------------------------

const Token &Tokenizer::getToken(int index) const {

  assert(0 <= index && index < getTokenCount());

  return m_tokens[index];

}

//-------------------------------------------------------------------

void Tokenizer::reset() { m_index = 0; }

//-------------------------------------------------------------------

const Token &Tokenizer::getToken() { return getToken(m_index); }

//-------------------------------------------------------------------

Token Tokenizer::nextToken() {

  Token token = getToken();

  if (m_index + 1 < getTokenCount()) m_index++;

  return token;

}

//-------------------------------------------------------------------

bool Tokenizer::eos() const { return m_index + 1 == getTokenCount(); }

//-------------------------------------------------------------------

Token Tokenizer::getTokenFromPos(int pos) const {

  int len = m_buffer.length();

  if (pos < 0 || pos >= len) return Token(pos);

  int x = 0;

  for (int i = 0; i < getTokenCount(); i++) {

    const Token &token = getToken(i);

    int y              = token.getPos();

    if (pos < y) {

      assert(x < y);

      return Token(x, y - 1);

    }

    x = y + (int)token.getText().length();

    if (pos < x) return token;

  }

  assert(x < len);

  return Token(x, len - 1);

}

//===================================================================

}  // TSyntax