/*  Copyright (C) 2022-2025 Davide Faconti -  All Rights Reserved
*
*   Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
*   to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
*   and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*   The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
*   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
*   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
*   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

#include "behaviortree_cpp/scripting/any_types.hpp"

#include <cctype>

namespace BT::Scripting
{

namespace
{

bool isIdentStart(char c)
{
  return std::isalpha(static_cast<unsigned char>(c)) != 0 || c == '_' || c == '@';
}

bool isIdentChar(char c)
{
  return std::isalnum(static_cast<unsigned char>(c)) != 0 || c == '_';
}

bool isDigit(char c)
{
  return std::isdigit(static_cast<unsigned char>(c)) != 0;
}

bool isHexDigit(char c)
{
  return std::isxdigit(static_cast<unsigned char>(c)) != 0;
}

// Consume trailing garbage after a malformed number token.
void consumeTrailingGarbage(const std::string& source, size_t len, size_t& i)
{
  while(i < len && (isIdentChar(source[i]) || source[i] == '.'))
  {
    ++i;
  }
}

struct NumberResult
{
  bool is_real = false;
  bool has_error = false;
};

NumberResult scanHexNumber(const std::string& source, size_t len, size_t& i)
{
  NumberResult result;
  i += 2;  // skip "0x"/"0X"
  if(i >= len || !isHexDigit(source[i]))
  {
    result.has_error = true;
  }
  else
  {
    while(i < len && isHexDigit(source[i]))
    {
      ++i;
    }
  }
  // Hex numbers don't support dot or exponent
  if(i < len && (source[i] == '.' || isIdentChar(source[i])))
  {
    result.has_error = true;
    consumeTrailingGarbage(source, len, i);
  }
  return result;
}

NumberResult scanDecimalNumber(const std::string& source, size_t len, size_t& i)
{
  NumberResult result;

  // Integer part
  while(i < len && isDigit(source[i]))
  {
    ++i;
  }
  // Fractional part
  if(i < len && source[i] == '.')
  {
    // Distinguish from ".." (concat operator)
    if(i + 1 < len && source[i + 1] == '.')
    {
      // Stop here: "65.." is Integer("65") + DotDot
    }
    else if(i + 1 < len && isDigit(source[i + 1]))
    {
      result.is_real = true;
      ++i;  // consume '.'
      while(i < len && isDigit(source[i]))
      {
        ++i;
      }
    }
    else
    {
      // "65." or "65.x" -- incomplete real
      result.has_error = true;
      ++i;  // consume the dot
      consumeTrailingGarbage(source, len, i);
    }
  }
  // Exponent (only for decimal numbers)
  if(!result.has_error && i < len && (source[i] == 'e' || source[i] == 'E'))
  {
    result.is_real = true;
    ++i;  // consume 'e'/'E'
    if(i < len && (source[i] == '+' || source[i] == '-'))
    {
      ++i;  // consume sign
    }
    if(i >= len || !isDigit(source[i]))
    {
      result.has_error = true;
    }
    else
    {
      while(i < len && isDigit(source[i]))
      {
        ++i;
      }
    }
  }
  // Trailing alpha (e.g. "3foo", "65.43foo")
  if(!result.has_error && i < len && isIdentStart(source[i]))
  {
    result.has_error = true;
    while(i < len && isIdentChar(source[i]))
    {
      ++i;
    }
  }
  return result;
}

TokenType matchTwoCharOp(char c, char next)
{
  if(c == '.' && next == '.')
    return TokenType::DotDot;
  if(c == '&' && next == '&')
    return TokenType::AmpAmp;
  if(c == '|' && next == '|')
    return TokenType::PipePipe;
  if(c == '=' && next == '=')
    return TokenType::EqualEqual;
  if(c == '!' && next == '=')
    return TokenType::BangEqual;
  if(c == '<' && next == '=')
    return TokenType::LessEqual;
  if(c == '>' && next == '=')
    return TokenType::GreaterEqual;
  if(c == ':' && next == '=')
    return TokenType::ColonEqual;
  if(c == '+' && next == '=')
    return TokenType::PlusEqual;
  if(c == '-' && next == '=')
    return TokenType::MinusEqual;
  if(c == '*' && next == '=')
    return TokenType::StarEqual;
  if(c == '/' && next == '=')
    return TokenType::SlashEqual;
  return TokenType::Error;
}

TokenType matchSingleCharOp(char c)
{
  switch(c)
  {
    case '+':
      return TokenType::Plus;
    case '-':
      return TokenType::Minus;
    case '*':
      return TokenType::Star;
    case '/':
      return TokenType::Slash;
    case '&':
      return TokenType::Ampersand;
    case '|':
      return TokenType::Pipe;
    case '^':
      return TokenType::Caret;
    case '~':
      return TokenType::Tilde;
    case '!':
      return TokenType::Bang;
    case '<':
      return TokenType::Less;
    case '>':
      return TokenType::Greater;
    case '=':
      return TokenType::Equal;
    case '?':
      return TokenType::Question;
    case ':':
      return TokenType::Colon;
    case '(':
      return TokenType::LeftParen;
    case ')':
      return TokenType::RightParen;
    case ';':
      return TokenType::Semicolon;
    default:
      return TokenType::Error;
  }
}

}  // namespace

std::vector<Token> tokenize(const std::string& source)
{
  std::vector<Token> tokens;
  const size_t len = source.size();
  size_t i = 0;

  while(i < len)
  {
    const char c = source[i];

    // Skip whitespace (space, tab, newline, carriage return)
    if(c == ' ' || c == '\t' || c == '\n' || c == '\r')
    {
      ++i;
      continue;
    }

    const size_t start = i;

    // Single-quoted string literal
    if(c == '\'')
    {
      ++i;
      while(i < len && source[i] != '\'')
      {
        ++i;
      }
      if(i < len)
      {
        // extract content without quotes
        std::string_view text(&source[start + 1], i - start - 1);
        tokens.push_back({ TokenType::String, text, start });
        ++i;  // skip closing quote
      }
      else
      {
        std::string_view text(&source[start], i - start);
        tokens.push_back({ TokenType::Error, text, start });
      }
      continue;
    }

    // Number literal (integer or real)
    if(isDigit(c))
    {
      NumberResult nr;
      const bool is_hex =
          c == '0' && i + 1 < len && (source[i + 1] == 'x' || source[i + 1] == 'X');
      if(is_hex)
      {
        nr = scanHexNumber(source, len, i);
      }
      else
      {
        nr = scanDecimalNumber(source, len, i);
      }

      std::string_view text(&source[start], i - start);
      if(nr.has_error)
      {
        tokens.push_back({ TokenType::Error, text, start });
      }
      else if(nr.is_real)
      {
        tokens.push_back({ TokenType::Real, text, start });
      }
      else
      {
        tokens.push_back({ TokenType::Integer, text, start });
      }
      continue;
    }

    // Identifier or keyword (true/false)
    if(isIdentStart(c))
    {
      ++i;  // consume start character (may not be isIdentChar, e.g. '@')
      while(i < len && isIdentChar(source[i]))
      {
        ++i;
      }
      if(std::string_view text(&source[start], i - start); text == "true" || text == "fal"
                                                                                     "se")
      {
        tokens.push_back({ TokenType::Boolean, text, start });
      }
      else
      {
        tokens.push_back({ TokenType::Identifier, text, start });
      }
      continue;
    }

    // Two-character operators (check before single-char)
    if(i + 1 < len)
    {
      TokenType two_char_type = matchTwoCharOp(c, source[i + 1]);
      if(two_char_type != TokenType::Error)
      {
        std::string_view text(&source[start], 2);
        tokens.push_back({ two_char_type, text, start });
        i += 2;
        continue;
      }
    }

    // Single-character operators and delimiters
    std::string_view text(&source[start], 1);
    tokens.push_back({ matchSingleCharOp(c), text, start });
    ++i;
  }

  // Sentinel
  tokens.push_back({ TokenType::EndOfInput, {}, i });
  return tokens;
}

}  // namespace BT::Scripting