/*

  This file is part of solidity.

  solidity is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  solidity is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License

  along with solidity.  If not, see <http://www.gnu.org/licenses/>.

*/

// SPDX-License-Identifier: GPL-3.0

#include <libsolidity/analysis/ConstantEvaluator.h>

#include <libsolidity/ast/AST.h>

#include <libsolidity/ast/ASTUtils.h>

#include <libsolidity/ast/ASTVisitor.h>

#include <libsolutil/Algorithms.h>

namespace solidity::frontend

{

ASTNode const* locateInnermostASTNode(int _offsetInFile, SourceUnit const& _sourceUnit)

{

  ASTNode const* innermostMatch = nullptr;

  auto locator = SimpleASTVisitor(

    [&](ASTNode const& _node) -> bool

    {

      // In the AST parent location always covers the whole child location.

      // The parent is visited first so to get the innermost node we simply

      // take the last one that still contains the offset.

      if (!_node.location().containsOffset(_offsetInFile))

        return false;

      innermostMatch = &_node;

      return true;

    },

    [](ASTNode const&) {}

  );

  _sourceUnit.accept(locator);

  return innermostMatch;

}

bool isConstantVariableRecursive(VariableDeclaration const& _varDecl)

{

  solAssert(_varDecl.isConstant(), "Constant variable expected");

  auto visitor = [](VariableDeclaration const& _variable, util::CycleDetector<VariableDeclaration>& _cycleDetector, size_t _depth)

  {

    solAssert(_depth < 256, "Recursion depth limit reached");

    if (!_variable.value())

      // This should result in an error later on.

      return;

    if (auto referencedVarDecl = dynamic_cast<VariableDeclaration const*>(

      ASTNode::referencedDeclaration(*_variable.value()))

    )

      if (referencedVarDecl->isConstant())

        _cycleDetector.run(*referencedVarDecl);

  };

  return util::CycleDetector<VariableDeclaration>(visitor).run(_varDecl) != nullptr;

}

VariableDeclaration const* rootConstVariableDeclaration(VariableDeclaration const& _varDecl)

{

  solAssert(_varDecl.isConstant(), "Constant variable expected");

  solAssert(!isConstantVariableRecursive(_varDecl), "Recursive declaration");

  VariableDeclaration const* rootDecl = &_varDecl;

  Identifier const* identifier;

  while ((identifier = dynamic_cast<Identifier const*>(rootDecl->value().get())))

  {

    auto referencedVarDecl = dynamic_cast<VariableDeclaration const*>(identifier->annotation().referencedDeclaration);

    if (!referencedVarDecl || !referencedVarDecl->isConstant())

      return nullptr;

    rootDecl = referencedVarDecl;

  }

  return rootDecl;

}

Expression const* resolveOuterUnaryTuples(Expression const* _expr)

{

  while (auto const* tupleExpression = dynamic_cast<TupleExpression const*>(_expr))

    if (tupleExpression->components().size() == 1)

      _expr = tupleExpression->components().front().get();

    else

      break;

  return _expr;

}

Type const* type(Expression const& _expression)

{

  solAssert(!!_expression.annotation().type, "Type requested but not present.");

  return _expression.annotation().type;

}

Type const* type(VariableDeclaration const& _variable)

{

  solAssert(!!_variable.annotation().type, "Type requested but not present.");

  return _variable.annotation().type;

}

bigint contractStorageSizeUpperBound(ContractDefinition const& _contract, VariableDeclaration::Location _location)

{

  solAssert(_location == VariableDeclaration::Location::Unspecified || _location == VariableDeclaration::Location::Transient);

  bigint size = 0;

  for (ContractDefinition const* contract: _contract.annotation().linearizedBaseContracts)

    for (VariableDeclaration const* variable: contract->stateVariables())

      if (

        !(variable->isConstant() || variable->immutable()) &&

        variable->referenceLocation() == _location

      )

        size += variable->annotation().type->storageSizeUpperBound();

  return size;

}

u256 layoutBaseForInheritanceHierarchy(ContractDefinition const& _topLevelContract, DataLocation _location)

{

  if (_location != DataLocation::Storage)

  {

    solAssert(_location == DataLocation::Transient);

    return 0;

  }

  if (auto const* storageLayoutSpecifier = _topLevelContract.storageLayoutSpecifier())

    return *storageLayoutSpecifier->annotation().baseSlot;

  return 0;

}

std::optional<u256> erc7201CompileTimeValue(FunctionCall const& _erc7201Call)

{

  auto const* erc7201Function = dynamic_cast<MagicVariableDeclaration const*>(ASTNode::referencedDeclaration(_erc7201Call.expression()));

  solAssert(erc7201Function);

  solAssert(erc7201Function->functionType(true /* internal */)->kind() == FunctionType::Kind::ERC7201);

  auto evaluatedResult = ConstantEvaluator::tryEvaluate(_erc7201Call);

  if (std::holds_alternative<std::monostate>(evaluatedResult.value))

    return std::nullopt;

  solAssert(std::holds_alternative<rational>(evaluatedResult.value));

  auto rationalValue = std::get<rational>(evaluatedResult.value);

  solAssert(rationalValue.denominator() == 1);

  bigint baseSlot = rationalValue.numerator();

  solAssert(baseSlot <= std::numeric_limits<u256>::max());

  return u256(baseSlot);

}

}