/*

  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 <libsolutil/IpfsHash.h>

#include <libsolutil/Exceptions.h>

#include <libsolutil/picosha2.h>

#include <libsolutil/CommonData.h>

#include <libsolutil/Numeric.h>

using namespace solidity;

using namespace solidity::util;

namespace

{

bytes varintEncoding(size_t _n)

{

  bytes encoded;

  while (_n > 0x7f)

  {

    encoded.emplace_back(uint8_t(0x80 | (_n & 0x7f)));

    _n >>= 7;

  }

  encoded.emplace_back(_n);

  return encoded;

}

bytes encodeByteArray(bytes const& _data)

{

  return bytes{0x0a} + varintEncoding(_data.size()) + _data;

}

bytes encodeHash(bytes const& _data)

{

  return bytes{0x12, 0x20} + picosha2::hash256(_data);

}

bytes encodeLinkData(bytes const& _data)

{

  return bytes{0x12} + varintEncoding(_data.size()) + _data;

}

std::string base58Encode(bytes const& _data)

{

  static std::string const alphabet{"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"};

  bigint data(util::toHex(_data, HexPrefix::Add));

  std::string output;

  while (data)

  {

    output += alphabet[static_cast<size_t>(data % alphabet.size())];

    data /= alphabet.size();

  }

  reverse(output.begin(), output.end());

  return output;

}

struct Chunk

{

  Chunk() = default;

  Chunk(bytes _hash, size_t _size, size_t _blockSize):

    hash(std::move(_hash)),

    size(_size),

    blockSize(_blockSize)

  {}

  bytes hash = {};

  size_t size = 0;

  size_t blockSize = 0;

};

using Chunks = std::vector<Chunk>;

Chunk combineLinks(Chunks& _links)

{

  bytes data = {};

  bytes lengths = {};

  Chunk chunk = {};

  for (Chunk& link: _links)

  {

    chunk.size += link.size;

    chunk.blockSize += link.blockSize;

    data += encodeLinkData(

      bytes {0x0a} +

      varintEncoding(link.hash.size()) +

      std::move(link.hash) +

      bytes{0x12, 0x00, 0x18} +

      varintEncoding(link.blockSize)

    );

    lengths += bytes{0x20} + varintEncoding(link.size);

  }

  bytes blockData = data + encodeByteArray(bytes{0x08, 0x02, 0x18} + varintEncoding(chunk.size) + lengths);

  chunk.blockSize += blockData.size();

  chunk.hash = encodeHash(blockData);

  return chunk;

}

Chunks buildNextLevel(Chunks& _currentLevel)

{

  size_t const maxChildNum = 174;

  Chunks nextLevel;

  Chunks links;

  for (Chunk& chunk: _currentLevel)

  {

    links.emplace_back(std::move(chunk.hash), chunk.size, chunk.blockSize);

    if (links.size() == maxChildNum)

    {

      nextLevel.emplace_back(combineLinks(links));

      links = {};

    }

  }

  if (!links.empty())

    nextLevel.emplace_back(combineLinks(links));

  return nextLevel;

}

/// Builds a tree starting from the bottom level where nodes are data nodes.

/// Data nodes should be calculated and passed as the only level in chunk levels

/// Each next level is calculated as following:

///   - Pick up to maxChildNum (174) nodes until a whole level is added, group them and pass to the node in the next level

///   - Do this until the current level has only one node, return the hash in that node

bytes groupChunksBottomUp(Chunks _currentLevel)

{

  // when we reach root it will be the only node in that level

  while (_currentLevel.size() != 1)

    _currentLevel = buildNextLevel(_currentLevel);

  // top level's only node stores the hash for file

  return _currentLevel.front().hash;

}

}

bytes solidity::util::ipfsHash(std::string _data)

{

  size_t const maxChunkSize = 1024 * 256;

  size_t chunkCount = _data.length() / maxChunkSize + (_data.length() % maxChunkSize > 0 ? 1 : 0);

  chunkCount = chunkCount == 0 ? 1 : chunkCount;

  Chunks allChunks;

  for (size_t chunkIndex = 0; chunkIndex < chunkCount; chunkIndex++)

  {

    bytes chunkBytes = asBytes(

      _data.substr(chunkIndex * maxChunkSize, std::min(maxChunkSize, _data.length() - chunkIndex * maxChunkSize))

    );

    bytes lengthAsVarint = varintEncoding(chunkBytes.size());

    bytes protobufEncodedData;

    // Type: File

    protobufEncodedData += bytes{0x08, 0x02};

    if (!chunkBytes.empty())

    {

      // Data (length delimited bytes)

      protobufEncodedData += bytes{0x12};

      protobufEncodedData += lengthAsVarint;

      protobufEncodedData += chunkBytes;

    }

    // filesize: length as varint

    protobufEncodedData += bytes{0x18} + lengthAsVarint;

    // PBDag:

    // Data: (length delimited bytes)

    bytes blockData = encodeByteArray(protobufEncodedData);

    // Multihash: sha2-256, 256 bits

    allChunks.emplace_back(

      encodeHash(blockData),

      chunkBytes.size(),

      blockData.size()

    );

  }

  return groupChunksBottomUp(std::move(allChunks));

}

std::string solidity::util::ipfsHashBase58(std::string _data)

{

  return base58Encode(ipfsHash(std::move(_data)));

}