use core::abi::{ByteInput, BytesView}

use super::mem

use super::ops

use super::effects::RawStorage

use super::storage_map::{StorageKey, StorageMap}

/// Round `len` up to the number of whole EVM words required to store it.

pub fn ceil_words(_ len: u256) -> u256 {

if len == 0 {

return 0

}

((len - 1) / 32) + 1

}

/// Mask that preserves the first `rem` bytes of a 32-byte word.

pub fn mask_for_bytes(rem: u256) -> u256 {

if rem == 0 {

return 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff

}

let shift = (32 - rem) * 8

0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff << shift

}

/// Zero the right-padding bytes after copying a dynamic byte slice into memory.

pub fn zero_pad_memory_bytes(ptr: u256, len: u256) {

let rem = len % 32

if rem == 0 {

return

}

let tail_ptr = ptr + (len / 32) * 32

let word = ops::mload(tail_ptr)

ops::mstore(addr: tail_ptr, value: word & mask_for_bytes(rem))

}

fn copy_view_words_to_memory<I>(_ view: BytesView<I>, _ dest: u256)

where I: ByteInput

{

let word_count = ceil_words(view.len())

let mut i: u256 = 0

while i < word_count {

let mut word = view.word_at(i * 32)

if i + 1 == word_count {

let rem = view.len() % 32

if rem != 0 {

word = word & mask_for_bytes(rem)

}

}

ops::mstore(addr: dest + i * 32, value: word)

i += 1

}

}

/// Return ABI-encoded `bytes` copied directly from calldata.

///

/// `data_ptr` is a raw calldata byte offset.

pub fn encode_bytes_return_from_calldata(data_ptr: u256, len: u256) -> ! {

let total_len = 64 + ceil_words(len) * 32

let ptr = mem::alloc(total_len)

ops::mstore(addr: ptr, value: 32)

ops::mstore(addr: ptr + 32, value: len)

ops::calldatacopy(dest: ptr + 64, offset: data_ptr, len: len)

zero_pad_memory_bytes(ptr: ptr + 64, len: len)

ops::return_data(offset: ptr, len: total_len)

}

/// Return ABI-encoded `bytes` copied from an arbitrary byte view.

pub fn encode_bytes_return_view<I>(view: BytesView<I>) -> !

where I: ByteInput

{

let len = view.len()

let total_len = 64 + ceil_words(len) * 32

let ptr = mem::alloc(total_len)

ops::mstore(addr: ptr, value: 32)

ops::mstore(addr: ptr + 32, value: len)

copy_view_words_to_memory(view, ptr + 64)

ops::return_data(offset: ptr, len: total_len)

}

/// Emit a Solidity-compatible event with a single dynamic `bytes` payload.

///

/// `data_ptr` is a raw calldata byte offset.

pub fn emit_bytes_event(topic0: u256, data_ptr: u256, data_len: u256) {

let total_len = 64 + ceil_words(data_len) * 32

let ptr = mem::alloc(total_len)

ops::mstore(addr: ptr, value: 32)

ops::mstore(addr: ptr + 32, value: data_len)

ops::calldatacopy(dest: ptr + 64, offset: data_ptr, len: data_len)

zero_pad_memory_bytes(ptr: ptr + 64, len: data_len)

ops::log1(offset: ptr, len: total_len, topic0: topic0)

}

/// Emit a Solidity-compatible event with a single dynamic `bytes` payload.

pub fn emit_bytes_event_view<I>(topic0: u256, view: BytesView<I>)

where I: ByteInput

{

let total_len = 64 + ceil_words(view.len()) * 32

let ptr = mem::alloc(total_len)

ops::mstore(addr: ptr, value: 32)

ops::mstore(addr: ptr + 32, value: view.len())

copy_view_words_to_memory(view, ptr + 64)

ops::log1(offset: ptr, len: total_len, topic0: topic0)

}

/// Storage-backed dynamic bytes keyed by `K`.

///

/// This uses two scalar `StorageMap`s internally:

/// - `LEN_SALT`: byte lengths

/// - `WORD_SALT`: 32-byte payload words

struct StorageBytesSeal {}

pub struct StorageBytes<K, const LEN_SALT: u256 = _, const WORD_SALT: u256 = _> {

seal: StorageBytesSeal,

}

impl<K: StorageKey + Copy, const LEN_SALT: u256, const WORD_SALT: u256>

StorageBytes<K, LEN_SALT, WORD_SALT>

{

pub(ingot) fn new_unchecked() -> Self {

Self { seal: StorageBytesSeal {} }

}

pub fn new() -> Self

uses (storage: mut RawStorage)

{

Self::new_unchecked()

}

pub fn len(self, key: K) -> u256 {

let lengths: StorageMap<K, u256, LEN_SALT> = StorageMap::new_unchecked()

lengths.get_unchecked(key)

}

pub fn clear(mut self, key: K) {

let mut lengths: StorageMap<K, u256, LEN_SALT> = StorageMap::new_unchecked()

let mut words: StorageMap<(K, u256), u256, WORD_SALT> = StorageMap::new_unchecked()

let len = lengths.get_unchecked(key)

let word_count = ceil_words(len)

let mut i: u256 = 0

while i < word_count {

words.set_unchecked(key: (key, i), value: 0)

i += 1

}

lengths.set_unchecked(key: key, value: 0)

}

/// Store bytes copied directly from calldata.

///

/// `data_ptr` is a raw calldata byte offset.

pub fn store_from_calldata(mut self, key: K, data_ptr: u256, len: u256) {

self.clear(key)

let mut lengths: StorageMap<K, u256, LEN_SALT> = StorageMap::new_unchecked()

let mut words: StorageMap<(K, u256), u256, WORD_SALT> = StorageMap::new_unchecked()

lengths.set_unchecked(key: key, value: len)

let word_count = ceil_words(len)

let mut i: u256 = 0

while i < word_count {

let mut word = ops::calldataload(data_ptr + i * 32)

if i + 1 == word_count {

let rem = len % 32

if rem != 0 {

word = word & mask_for_bytes(rem)

}

}

words.set_unchecked(key: (key, i), value: word)

i += 1

}

}

/// Store bytes from an arbitrary ABI byte view.

pub fn store_view<I>(mut self, key: K, view: BytesView<I>)

where I: ByteInput

{

self.clear(key)

let mut lengths: StorageMap<K, u256, LEN_SALT> = StorageMap::new_unchecked()

let mut words: StorageMap<(K, u256), u256, WORD_SALT> = StorageMap::new_unchecked()

lengths.set_unchecked(key: key, value: view.len())

let word_count = ceil_words(view.len())

let mut i: u256 = 0

while i < word_count {

let mut word = view.word_at(i * 32)

if i + 1 == word_count {

let rem = view.len() % 32

if rem != 0 {

word = word & mask_for_bytes(rem)

}

}

words.set_unchecked(key: (key, i), value: word)

i += 1

}

}

/// Copy the stored bytes into freshly allocated memory.

///

/// Returns the memory offset of the first payload byte and the byte

/// length. Unlike `encode_return`, this does not end the call, so the

/// bytes can be post-processed (hashed, deployed via `create2_raw`, etc).

/// The trailing partial word, if any, is zero-padded.

pub fn to_memory(self, key: K) -> (u256, u256) {

let lengths: StorageMap<K, u256, LEN_SALT> = StorageMap::new_unchecked()

let words: StorageMap<(K, u256), u256, WORD_SALT> = StorageMap::new_unchecked()

let len = lengths.get_unchecked(key)

let word_count = ceil_words(len)

let ptr = mem::alloc(word_count * 32)

let mut i: u256 = 0

while i < word_count {

ops::mstore(addr: ptr + i * 32, value: words.get_unchecked((key, i)))

i += 1

}

(ptr, len)

}

/// Load the 32-byte payload word at word `index` for `key`.

///

/// The last word of a non-word-multiple length is zero-padded; indices

/// past `ceil_words(len(key))` read as zero.

pub fn word_at(self, key: K, index: u256) -> u256 {

let words: StorageMap<(K, u256), u256, WORD_SALT> = StorageMap::new_unchecked()

words.get_unchecked((key, index))

}

/// Return ABI-encoded `bytes` from storage.

pub fn encode_return(self, key: K) -> ! {

let lengths: StorageMap<K, u256, LEN_SALT> = StorageMap::new_unchecked()

let words: StorageMap<(K, u256), u256, WORD_SALT> = StorageMap::new_unchecked()

let len = lengths.get_unchecked(key)

let word_count = ceil_words(len)

let total_len = 64 + word_count * 32

let ptr = mem::alloc(total_len)

ops::mstore(addr: ptr, value: 32)

ops::mstore(addr: ptr + 32, value: len)

let mut i: u256 = 0

while i < word_count {

ops::mstore(addr: ptr + 64 + i * 32, value: words.get_unchecked((key, i)))

i += 1

}

ops::return_data(offset: ptr, len: total_len)

}

}