#!/usr/bin/env python
# -*- coding: utf-8 -*-
# flake8: noqa

# ====================================
# Cryptocurrency Validation Functions
# BTC, LTC, XMR
#
# Code modified from:
#
# Base58 decoding: https://github.com/keis/base58
# P2PKH validation: http://bit.ly/2DSVAXc
# Bech32 Validation: http://bit.ly/2Eaw40N
# XMR Validation: https://github.com/monero-project
# ====================================

import os
import sys

if os.path.exists(os.getcwd() + "\\venv"):
    sys.path.append(os.getcwd() + "\\venv\\Lib\\site-packages")
import operator as _oper
import re
import struct
from binascii import hexlify, unhexlify
from decimal import Decimal

import base58
import sha3

# --------------------- Global Variables -------------------- #


_ADDR_REGEX = re.compile(
    r"^[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{95}$"
)
_IADDR_REGEX = re.compile(
    r"^[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{106}$"
)
_str_types = (str, bytes)
__alphabet = [
    ord(s) for s in "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
]
__UINT64MAX = 2**64
__encodedBlockSizes = [0, 2, 3, 5, 6, 7, 9, 10, 11]
__fullBlockSize = 8
__fullEncodedBlockSize = 11
indexbytes = _oper.getitem
intlist2bytes = bytes
int2byte = _oper.methodcaller("to_bytes", 1, "big")
b = 256
q = 2**255 - 19
l = 2**252 + 27742317777372353535851937790883648493  # noqa
PICONERO = Decimal("0.000000000001")
EMPTY_KEY = "0" * 64
_integer_types = (int,)


# ----------------- Global Functions ----------------- @


def to_atomic(amount):
    """Convert Monero decimal to atomic integer of piconero."""
    if not isinstance(amount, (Decimal, float) + _integer_types):
        raise ValueError(
            "Amount '{}' doesn't have numeric type. Only Decimal, int, long and "
            "float (not recommended) are accepted as amounts."
        )
    return int(amount * 10**12)


def from_atomic(amount):
    """Convert atomic integer of piconero to Monero decimal."""
    return (Decimal(amount) * PICONERO).quantize(PICONERO)


def as_monero(amount):
    """Return the amount rounded to maximal Monero precision."""
    return Decimal(amount).quantize(PICONERO)


def _hexToBin(hex_):
    if len(hex_) % 2 != 0:
        raise ValueError("Hex string has invalid length: %d" % len(hex_))
    return [int(hex_[i : i + 2], 16) for i in range(0, len(hex_), 2)]  # noqa


def _binToHex(bin_):
    return "".join("%02x" % int(b) for b in bin_)


def _uint8be_to_64(data):
    if not (1 <= len(data) <= 8):
        raise ValueError("Invalid input length: %d" % len(data))

    res = 0
    for b in data:
        res = res << 8 | b
    return res


def _uint64_to_8be(num, size):
    if size < 1 or size > 8:
        raise ValueError("Invalid input length: %d" % size)
    res = [0] * size

    twopow8 = 2**8
    for i in range(size - 1, -1, -1):
        res[i] = num % twopow8
        num = num // twopow8

    return res


def xmr_base58_encode_block(data, buf, index):
    l_data = len(data)

    if l_data < 1 or l_data > __fullEncodedBlockSize:
        raise ValueError("Invalid block length: %d" % l_data)

    num = _uint8be_to_64(data)
    i = __encodedBlockSizes[l_data] - 1

    while num > 0:
        remainder = num % 58
        num = num // 58
        buf[index + i] = __alphabet[remainder]
        i -= 1

    return buf


def xmr_base58_encode(hex):
    """Encode hexadecimal string as base58 (ex: encoding a Monero address)."""
    data = _hexToBin(hex)
    l_data = len(data)

    if l_data == 0:
        return ""

    full_block_count = l_data // __fullBlockSize
    last_block_size = l_data % __fullBlockSize
    res_size = (
        full_block_count * __fullEncodedBlockSize + __encodedBlockSizes[last_block_size]
    )

    res = bytearray([__alphabet[0]] * res_size)

    for i in range(full_block_count):
        res = xmr_base58_encode_block(
            data[(i * __fullBlockSize) : (i * __fullBlockSize + __fullBlockSize)],
            res,
            i * __fullEncodedBlockSize,
        )

    if last_block_size > 0:
        res = xmr_base58_encode_block(
            data[
                (full_block_count * __fullBlockSize) : (
                    full_block_count * __fullBlockSize + last_block_size
                )
            ],
            res,
            full_block_count * __fullEncodedBlockSize,
        )

    return bytes(res).decode("ascii")


def xmr_base58_decode_block(data, buf, index):
    l_data = len(data)

    if l_data < 1 or l_data > __fullEncodedBlockSize:
        raise ValueError("Invalid block length: %d" % l_data)

    res_size = __encodedBlockSizes.index(l_data)
    if res_size <= 0:
        raise ValueError("Invalid block size: %d" % res_size)

    res_num = 0
    order = 1
    for i in range(l_data - 1, -1, -1):
        digit = __alphabet.index(data[i])
        if digit < 0:
            raise ValueError("Invalid symbol: %s" % data[i])

        product = order * digit + res_num
        if product > __UINT64MAX:
            raise ValueError(
                "Overflow: %d * %d + %d = %d" % (order, digit, res_num, product)
            )

        res_num = product
        order = order * 58

    if res_size < __fullBlockSize and 2 ** (8 * res_size) <= res_num:
        raise ValueError("Overflow: %d doesn't fit in %d bit(s)" % (res_num, res_size))

    tmp_buf = _uint64_to_8be(res_num, res_size)
    buf[index : index + len(tmp_buf)] = tmp_buf

    return buf


def xmr_base58_decode(enc):
    """Decode a base58 string (ex: a Monero address) into hexidecimal form."""
    enc = bytearray(enc, encoding="ascii")
    l_enc = len(enc)

    if l_enc == 0:
        return ""

    full_block_count = l_enc // __fullEncodedBlockSize
    last_block_size = l_enc % __fullEncodedBlockSize
    try:
        last_block_decoded_size = __encodedBlockSizes.index(last_block_size)
    except ValueError:
        raise ValueError("Invalid encoded length: %d" % l_enc)

    data_size = full_block_count * __fullBlockSize + last_block_decoded_size

    data = bytearray(data_size)
    for i in range(full_block_count):
        data = xmr_base58_decode_block(
            enc[
                (i * __fullEncodedBlockSize) : (
                    i * __fullEncodedBlockSize + __fullEncodedBlockSize
                )
            ],
            data,
            i * __fullBlockSize,
        )

    if last_block_size > 0:
        data = xmr_base58_decode_block(
            enc[
                (full_block_count * __fullEncodedBlockSize) : (
                    full_block_count * __fullEncodedBlockSize + last_block_size
                )
            ],
            data,
            full_block_count * __fullBlockSize,
        )

    return _binToHex(data)


def expmod(b, e, m):
    if e == 0:
        return 1
    t = expmod(b, e // 2, m) ** 2 % m
    if e & 1:
        t = (t * b) % m
    return t


def inv(x):
    return expmod(x, q - 2, q)


d = -121665 * inv(121666)
I = expmod(2, (q - 1) // 4, q)


def xrecover(y):
    xx = (y * y - 1) * inv(d * y * y + 1)
    x = expmod(xx, (q + 3) // 8, q)
    if (x * x - xx) % q != 0:
        x = (x * I) % q
    if x % 2 != 0:
        x = q - x
    return x


def compress(P):
    zinv = inv(P[2])
    return (P[0] * zinv % q, P[1] * zinv % q)


def decompress(P):
    return (P[0], P[1], 1, P[0] * P[1] % q)


By = 4 * inv(5)
Bx = xrecover(By)
B = [Bx % q, By % q]


def edwards(P, Q):
    x1 = P[0]
    y1 = P[1]
    x2 = Q[0]
    y2 = Q[1]
    x3 = (x1 * y2 + x2 * y1) * inv(1 + d * x1 * x2 * y1 * y2)
    y3 = (y1 * y2 + x1 * x2) * inv(1 - d * x1 * x2 * y1 * y2)
    return [x3 % q, y3 % q]


def add(P, Q):
    A = (P[1] - P[0]) * (Q[1] - Q[0]) % q
    B = (P[1] + P[0]) * (Q[1] + Q[0]) % q
    C = 2 * P[3] * Q[3] * d % q
    D = 2 * P[2] * Q[2] % q
    E = B - A
    F = D - C
    G = D + C
    H = B + A
    return (E * F, G * H, F * G, E * H)


def add_compressed(P, Q):
    return compress(add(decompress(P), decompress(Q)))


def scalarmult(P, e):
    if e == 0:
        return [0, 1]
    Q = scalarmult(P, e // 2)
    Q = edwards(Q, Q)
    if e & 1:
        Q = edwards(Q, P)
    return Q


def encodeint(y):
    bits = [(y >> i) & 1 for i in range(b)]
    return b"".join(
        [int2byte(sum([bits[i * 8 + j] << j for j in range(8)])) for i in range(b // 8)]
    )


def encodepoint(P):
    x = P[0]
    y = P[1]
    bits = [(y >> i) & 1 for i in range(b - 1)] + [x & 1]
    return b"".join(
        [int2byte(sum([bits[i * 8 + j] << j for j in range(8)])) for i in range(b // 8)]
    )


def bit(h, i):
    return (indexbytes(h, i // 8) >> (i % 8)) & 1


def isoncurve(P):
    x = P[0]
    y = P[1]
    return (-x * x + y * y - 1 - d * x * x * y * y) % q == 0


def decodeint(s):
    return sum(2**i * bit(s, i) for i in range(0, b))


def decodepoint(s):
    y = sum(2**i * bit(s, i) for i in range(0, b - 1))
    x = xrecover(y)
    if x & 1 != bit(s, b - 1):
        x = q - x
    P = [x, y]
    if not isoncurve(P):
        raise Exception("decoding point that is not on curve")
    return P


def public_from_secret(k):
    keyInt = decodeint(k)
    aB = scalarmult(B, keyInt)
    return encodepoint(aB)


def public_from_secret_hex(hk):
    return hexlify(public_from_secret(unhexlify(hk))).decode()


def bech32_decode(bech):
    charset = "qpzry9x8gf2tvdw0s3jn54khce6mua7l"
    if (any(ord(x) < 33 or ord(x) > 126 for x in bech)) or (
        bech.lower() != bech and bech.upper() != bech
    ):
        return False
    bech = bech.lower()
    pos = bech.rfind("1")
    if pos < 1 or pos + 7 > len(bech) or len(bech) > 90:
        return False
    if not all(x in charset for x in bech[pos + 1 :]):
        return False
    hrp = bech[:pos]
    data = [charset.find(x) for x in bech[pos + 1 :]]
    if not bech32_verify_checksum(hrp, data):
        return False
    return True


def bech32_polymod(values):
    generator = [0x3B6A57B2, 0x26508E6D, 0x1EA119FA, 0x3D4233DD, 0x2A1462B3]
    chk = 1
    for value in values:
        top = chk >> 25
        chk = (chk & 0x1FFFFFF) << 5 ^ value
        for i in range(5):
            chk ^= generator[i] if ((top >> i) & 1) else 0
    return chk


def bech32_hrp_expand(hrp):
    return [ord(x) >> 5 for x in hrp] + [0] + [ord(x) & 31 for x in hrp]


def bech32_verify_checksum(hrp, data):
    return bech32_polymod(bech32_hrp_expand(hrp) + data) == 1


def hextobin(hexstr):
    if (hexstr.length % 2) is not 0:
        return False
    res = list()
    index = 0
    for char in hexstr:
        res[index] = int(hexstr[(index * 2) : (index * 2 + 2)])
        index += 1
    return res


# ------------------ Helper Classes ---------------- #


class BaseAddress(object):
    label = None

    def __init__(self, addr, label=None):
        addr = str(addr)
        if not _ADDR_REGEX.match(addr):
            raise ValueError(
                "Address must be 95 characters long base58-encoded string, "
                "is {addr} ({len} chars length)".format(addr=addr, len=len(addr))
            )
        self._decode(addr)
        self.label = label or self.label

    def is_mainnet(self):
        """Returns `True` if the address belongs to mainnet.
        :rtype: bool
        """
        return self._decoded[0] == self._valid_netbytes[0]

    def is_testnet(self):
        """Returns `True` if the address belongs to testnet.
        :rtype: bool
        """
        return self._decoded[0] == self._valid_netbytes[1]

    def is_stagenet(self):
        """Returns `True` if the address belongs to stagenet.
        :rtype: bool
        """
        return self._decoded[0] == self._valid_netbytes[2]

    def _decode(self, address):
        self._decoded = bytearray(unhexlify(xmr_base58_decode(address)))
        checksum = self._decoded[-4:]
        if checksum != sha3.keccak_256(self._decoded[:-4]).digest()[:4]:
            raise ValueError("Invalid checksum in address {}".format(address))
        if self._decoded[0] not in self._valid_netbytes:
            raise ValueError(
                "Invalid address netbyte {nb}. Allowed values are: {allowed}".format(
                    nb=self._decoded[0],
                    allowed=", ".join(map(lambda b: "%02x" % b, self._valid_netbytes)),
                )
            )

    def __repr__(self):
        return xmr_base58_encode(hexlify(self._decoded))

    def __eq__(self, other):
        if isinstance(other, BaseAddress):
            return str(self) == str(other)
        if isinstance(other, _str_types):
            return str(self) == other
        return super(BaseAddress, self).__eq__(other)

    def __hash__(self):
        return hash(str(self))


class Address(BaseAddress):
    """Monero address.
    Address of this class is the master address for a :class:`Wallet <monero.wallet.Wallet>`.
    :param address: a Monero address as string-like object
    :param label: a label for the address (defaults to `None`)
    """

    _valid_netbytes = (18, 53, 24)
    # NOTE: _valid_netbytes order is (mainnet, testnet, stagenet)

    def view_key(self):
        """Returns public view key.
        :rtype: str
        """
        return hexlify(self._decoded[33:65]).decode()

    def spend_key(self):
        """Returns public spend key.
        :rtype: str
        """
        return hexlify(self._decoded[1:33]).decode()

    def check_private_view_key(self, key):
        """Checks if private view key matches this address.
        :rtype: bool
        """
        return public_from_secret_hex(key) == self.view_key()

    def check_private_spend_key(self, key):
        """Checks if private spend key matches this address.
        :rtype: bool
        """
        return public_from_secret_hex(key) == self.spend_key()

    def with_payment_id(self, payment_id=0):
        """Integrates payment id into the address.
        :param payment_id: int, hexadecimal string or :class:`PaymentID <monero.numbers.PaymentID>`
                    (max 64-bit long)
        :rtype: `IntegratedAddress`
        :raises: `TypeError` if the payment id is too long
        """
        payment_id = PaymentID(payment_id)
        if not payment_id.is_short():
            raise TypeError(
                "Payment ID {0} has more than 64 bits and cannot be integrated".format(
                    payment_id
                )
            )
        prefix = 54 if self.is_testnet() else 25 if self.is_stagenet() else 19
        data = (
            bytearray([prefix])
            + self._decoded[1:65]
            + struct.pack(">Q", int(payment_id))
        )
        checksum = bytearray(sha3.keccak_256(data).digest()[:4])
        return IntegratedAddress(xmr_base58_encode(hexlify(data + checksum)))


class SubAddress(BaseAddress):
    """Monero subaddress.
    Any type of address which is not the master one for a wallet.
    """

    _valid_netbytes = (42, 63, 36)
    # NOTE: _valid_netbytes order is (mainnet, testnet, stagenet)

    def with_payment_id(self, _):
        raise TypeError("SubAddress cannot be integrated with payment ID")


class IntegratedAddress(Address):
    """Monero integrated address.
    A master address integrated with payment id (short one, max 64 bit).
    """

    _valid_netbytes = (19, 54, 25)
    # NOTE: _valid_netbytes order is (mainnet, testnet, stagenet)

    def __init__(self, address):
        address = str(address)
        if not _IADDR_REGEX.match(address):
            raise ValueError(
                "Integrated address must be 106 characters long base58-encoded string, "
                "is {addr} ({len} chars length)".format(addr=address, len=len(address))
            )
        self._decode(address)

    def payment_id(self):
        """Returns the integrated payment id.
        :rtype: :class:`PaymentID <monero.numbers.PaymentID>`
        """
        return PaymentID(hexlify(self._decoded[65:-4]).decode())

    def base_address(self):
        """Returns the base address without payment id.
        :rtype: :class:`Address`
        """
        prefix = 53 if self.is_testnet() else 24 if self.is_stagenet() else 18
        data = bytearray([prefix]) + self._decoded[1:65]
        checksum = sha3.keccak_256(data).digest()[:4]
        return Address(xmr_base58_encode(hexlify(data + checksum)))


class PaymentID(object):
    """
    A class that validates Monero payment ID.

    Payment IDs can be used as str or int across the module, however this class
    offers validation as well as simple conversion and comparison to those two
    primitive types.

    :param payment_id: the payment ID as integer or hexadecimal string
    """

    _payment_id = None

    def __init__(self, payment_id):
        if isinstance(payment_id, PaymentID):
            payment_id = int(payment_id)
        if isinstance(payment_id, _str_types):
            payment_id = int(payment_id, 16)
        elif not isinstance(payment_id, _integer_types):
            raise TypeError(
                "payment_id must be either int or hexadecimal str or bytes, "
                "is {0}".format(type(payment_id))
            )
        if payment_id.bit_length() > 256:
            raise ValueError(
                "payment_id {0} is more than 256 bits long".format(payment_id)
            )
        self._payment_id = payment_id

    def is_short(self):
        """Returns True if payment ID is short enough to be included
        in :class:`IntegratedAddress <monero.address.IntegratedAddress>`."""
        return self._payment_id.bit_length() <= 64

    def __repr__(self):
        if self.is_short():
            return "{:016x}".format(self._payment_id)
        return "{:064x}".format(self._payment_id)

    def __int__(self):
        return self._payment_id

    def __eq__(self, other):
        if isinstance(other, PaymentID):
            return int(self) == int(other)
        elif isinstance(other, _integer_types):
            return int(self) == other
        elif isinstance(other, _str_types):
            return str(self) == other
        return super(PaymentID, self).__eq__(other)


# ------------------ Validation Class ----------------- #


class Validation:
    @staticmethod
    def is_btc_chain(chain):
        chain = chain.lower()
        chains = ["main", "testnet"]
        if chain in chains:
            return True
        return False

    @staticmethod
    def is_xmr_chain(chain):
        chain = chain.lower()
        chains = ["mainnet", "testnet", "stagenet"]
        if chain in chains:
            return True
        return False

    @staticmethod
    def is_coin_ticker(coin):
        coin = coin.lower()
        coins = ["btc", "ltc", "xmr"]
        if coin in coins:
            return True
        return False

    @staticmethod
    def is_coin_name(coin):
        coin = coin.lower()
        coins = ["bitcoin", "litecoin", "monero"]
        if coin in coins:
            return True
        return False

    @staticmethod
    def is_address(coin, address):
        coin = coin.lower()
        if not Validation.is_coin_ticker(coin):
            return False
        address = address.strip()
        if coin == "btc":
            return Validation.is_btc_address(address)
        if coin == "ltc":
            return Validation.is_ltc_address(address)
        if coin == "xmr":
            return Validation.is_xmr_address(address)
        return False

    @staticmethod
    def is_btc_address(address):  # Level 4 Validation
        if address[0] == "1":  # P2PKH Address
            return base58.b58decode_check(address)
        elif address[0] == "3":  # P2SH Address
            return base58.b58decode_check(address)
        elif address[:3] == "bc1":  # Bech32 Addresses (Segwit)
            return bech32_decode(address)
        else:
            return False

    @staticmethod
    def is_ltc_address(address):  # Level 4 Validation
        if len(address) > 43 or len(address) < 26:
            return False
        if address[0] == "L":  # Legacy Non-P2SH Address
            return base58.b58decode_check(address)
        elif address[0] == "3":  # P2SH Address - Deprecated
            return False
        elif address[0] == "M":  # P2SH Address
            return base58.b58decode_check(address)
        elif address[:4] == "ltc1":  # P2WPKH Bech32 (Segwit)
            return bech32_decode(address)
        return False

    @staticmethod
    def is_xmr_address(address, label=None):  # Level 4 Validation
        addr = str(address)
        charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
        for char in address:
            if char not in charset:
                return False
        if len(address) not in [95, 106]:
            return False
        if _ADDR_REGEX.match(addr):
            try:
                netbyte = bytearray(unhexlify(xmr_base58_decode(addr)))[0]
                if netbyte in Address._valid_netbytes:
                    Address(addr, label=label)
                    return True
                elif netbyte in SubAddress._valid_netbytes:
                    SubAddress(addr, label=label)
                    return True
            except Exception:
                return False
        elif _IADDR_REGEX.match(addr):
            try:
                IntegratedAddress(addr)
                return True
            except Exception:
                return False
        return False