from hashlib import (
    sha256, md5,
    shake_128, shake_256,
    sha3_256, sha3_512,
    blake2b, blake2s
)


"""New randomized proof-of-work hashing algorithms inspired roughly by
    XMR's RandomX but much simpler and shoddier.
    Mirrors:
        https://pastebin.com/xY3B3K8S
        https://github.com/k98kurz/tapehash
"""

def tapehash1(preimage: bytes, code_size: int = 20) -> bytes:
    """Runs the tapehash 1 algorithm on the preimage and returns a
        32-byte hash. Computational complexity is tuneable via the
        `code_size` parameter.
    """
    if type(preimage) is not bytes:
        raise TypeError('preimage must be bytes')
    if type(code_size) is not int:
        raise TypeError('code_size must be an int between 1 and 65,536')
    if code_size <= 0 or code_size > 65_536:
        raise ValueError('code_size must be an int between 1 and 65,536')

    # generate the code and the tape
    code = shake_256(preimage).digest(code_size)
    tape = bytearray(blake2b(preimage).digest())

    # run the program
    for i in range(0, len(code)):
        opcode = code[i] >> 4
        #pointer = ((code[i] << 4) % 256) >> 4
        pointer = code[i] & 0b00001111
        double_pointer = int.from_bytes(code[i:i+2], 'big') % 2

        tape = execute_opcode(opcode, pointer, tape)
        tape = execute_opcode(opcode, pointer + 16, tape)
        tape = execute_opcode(opcode, pointer + 32, tape)
        tape = execute_opcode(opcode, pointer + 48, tape)

    return sha256(tape).digest()


def tapehash2(preimage: bytes, tape_size_multiplier: int = 2) -> bytes:
    """Runs the tapehash2 algorithm on the preimage and returns a
        32-byte hash. Memory complexity can be tuned via the
        `tape_size_multiplier` parameter.
    """
    if type(preimage) is not bytes:
        raise TypeError('preimage must be bytes')
    if type(tape_size_multiplier) is not int:
        raise TypeError('tape_size_multiplier must be an int between 1 and 65,536')
    if tape_size_multiplier <= 0 or tape_size_multiplier > 65_536:
        raise ValueError('tape_size_multiplier must be an int between 1 and 65,536')

    # generate the code and the tape
    code = blake2b(preimage).digest()
    tape = bytearray(shake_256(preimage).digest(tape_size_multiplier * 32))

    # run the program
    for i in range(0, len(code), 2):
        opcode = code[i] >> 4
        #pointer = ((code[i] << 4) % 256) >> 4
        pointer = code[i] & 0b00001111
        double_pointer = int.from_bytes(code[i:i+2], 'big') % tape_size_multiplier

        tape = execute_opcode(opcode, pointer + double_pointer * 32, tape)
        tape = execute_opcode(opcode, pointer + 16 + double_pointer * 32, tape)

    return sha256(tape).digest()


def tapehash3(
    preimage: bytes, code_size: int = 64, tape_size_multiplier: int = 2
) -> bytes:
    """Runs the tapehash3 algorithm on the preimage and returns a
        32-byte hash. Computational complexity is tuneable via the
        `code_size` parameter. Memory complexity is tuneable via the
        `tape_size_multiplier` parameter.
    """
    if type(preimage) is not bytes:
        raise TypeError('preimage must be bytes')
    if type(code_size) is not int:
        raise TypeError('code_size must be an int between 1 and 65,536')
    if code_size <= 0 or code_size > 65_536:
        raise ValueError('code_size must be an int between 1 and 65,536')
    if type(tape_size_multiplier) is not int:
        raise TypeError('tape_size_multiplier must be an int between 1 and 65,536')
    if tape_size_multiplier <= 0 or tape_size_multiplier > 65_536:
        raise ValueError('tape_size_multiplier must be an int between 1 and 65,536')

    # generate the code and the tape
    code = shake_256(preimage).digest(code_size)
    tape = bytearray(shake_256(preimage).digest(tape_size_multiplier * 32))

    # run the program
    for i in range(0, len(code), 2):
        opcode = code[i] >> 4
        #pointer = ((code[i] << 4) % 256) >> 4
        pointer = code[i] & 0b00001111
        double_pointer = int.from_bytes(code[i:i+2], 'big') % tape_size_multiplier

        tape = execute_opcode(opcode, pointer + double_pointer * 32, tape)
        tape = execute_opcode(opcode, pointer + 16 + double_pointer * 32, tape)

    return sha256(tape).digest()



def rotate_tape(tape: bytearray, pointer: int) -> bytes:
    """Rotates the tape so that the pointer-indexed byte is first."""
    if not isinstance(tape, bytearray):
        raise TypeError('tape must be bytearray')
    if not isinstance(pointer, int):
        raise TypeError('pointer must be int')
    if len(tape) < 1:
        raise ValueError('tape must not be empty')
    if pointer < 0 or pointer >= len(tape):
        raise ValueError('pointer must be a valid index of tape')

    new_tape = tape[pointer:]
    new_tape.extend(tape[:pointer])
    return bytes(new_tape)


def execute_opcode(opcode: int, pointer: int, tape: bytearray) -> bytearray:
    """Execute a single opcode."""
    if type(opcode) is not int:
        raise TypeError('opcode must be an int')
    if type(pointer) is not int:
        raise TypeError('pointer must be an int')
    if type(tape) is not bytearray:
        raise TypeError('tape must be bytearray')
    if opcode < 0 or opcode > 15:
        raise ValueError('opcode must be between 0 and 15')
    if pointer < 0 or pointer >= len(tape):
        raise ValueError('pointer must be a valid index of tape')

    operations = {
        0: lambda data: data, # no op
        1: lambda data: (data + 1) % 256,
        2: lambda data: data - 1 if data > 0 else 255,
        3: lambda data: data >> 1,
        4: lambda data: (data << 1) % 256,
        5: lambda data: data ^ 255,
        6: lambda data: (data * 2) % 256,
        7: lambda data: (data ** 2) % 256,
        8: lambda data: (data // 2) % 256,
        9: lambda data: ((data << 4) % 256) | (data >> 4),
        10: lambda data: sha256(data).digest()[data[0] % 32],
        11: lambda data: md5(data).digest()[data[0] % 16],
        12: lambda data: shake_128(data).digest(data[0] + 1)[data[0]],
        13: lambda data: sha3_256(data).digest()[data[0] % 32],
        14: lambda data: sha3_512(data).digest()[data[0] % 64],
        15: lambda data: blake2s(data).digest()[data[0] % 32]
    }

    if opcode < 10:
        tape[pointer] = operations[opcode](tape[pointer])
    else:
        tape[pointer] = operations[opcode](rotate_tape(tape, pointer))
    return tape


def license():
    """Copyright (c) 2026 Jonathan Voss (k98kurz)

        Permission to use, copy, modify, and/or distribute this software
        for any purpose with or without fee is hereby granted, provided
        that the above copyright notice and this permission notice appear in
        all copies.

        THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
        WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
        WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
        AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR
        CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
        OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
        NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
        CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
    """
    return license.__doc__