from datetime import datetime
from nacl import encoding, signing, hash, bindings
from re import compile, search
from sys import exit

from constants import G1_SYMBOL, GTEST_SYMBOL


def convert_time(timestamp, kind):
    ts = int(timestamp)
    date = "%Y-%m-%d"
    hour = "%H:%M"
    second = ":%S"
    if kind == "all":
        pattern = date + " " + hour + second
    elif kind == "date":
        pattern = date
    elif kind == "hour":
        pattern = hour
        if ts >= 3600:
            pattern += second
    return datetime.fromtimestamp(ts).strftime(pattern)


def get_currency_symbol(currency):
    if currency == "g1":
        return G1_SYMBOL
    elif currency == "g1-test":
        return GTEST_SYMBOL


def sign_document_from_seed(document, seed):
    seed = bytes(seed, 'utf-8')
    signing_key = signing.SigningKey(seed, encoding.HexEncoder)
    signed = signing_key.sign(bytes(document, 'utf-8'))
    signed_b64 = encoding.Base64Encoder.encode(signed.signature)
    return signed_b64.decode("utf-8")


def get_publickey_from_seed(seed):
    seed = bytes(seed, 'utf-8')
    seed = encoding.HexEncoder.decode(seed)
    public_key, secret_key = bindings.crypto_sign_seed_keypair(seed)
    return b58_encode(public_key)


def check_public_key(pubkey, display_error):
    """
    Check public key format
    Check pubkey checksum which could be append after the pubkey
    If check pass: return pubkey
    """
    regex = compile('^[1-9A-HJ-NP-Za-km-z]{43,44}$')
    regex_checksum = compile('^[1-9A-HJ-NP-Za-km-z]{43,44}' +
                                ':[1-9A-HJ-NP-Za-km-z]{3}$')
    if search(regex, pubkey):
        return pubkey
    elif search(regex_checksum, pubkey):
        pubkey, checksum = pubkey.split(":")
        pubkey_byte = b58_decode(pubkey)
        checksum_calculed = b58_encode(hash.sha256(
                    hash.sha256(pubkey_byte, encoding.RawEncoder),
                    encoding.RawEncoder))[:3]
        if checksum_calculed == checksum:
            return pubkey
        else:
            print("error: bad checksum of the public key")
            return False

    elif display_error:
        print("Error: the format of the public key is invalid")
    return False


b58_digits = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'


def b58_encode(b):

    # Convert big-endian bytes to integer
    n = int('0x0' + encoding.HexEncoder.encode(b).decode('utf8'), 16)

    # Divide that integer into base58
    res = []
    while n > 0:
        n, r = divmod(n, 58)
        res.append(b58_digits[r])
    res = ''.join(res[::-1])

    # Encode leading zeros as base58 zeros
    czero = 0
    pad = 0
    for c in b:
        if c == czero:
            pad += 1
        else:
            break
    return b58_digits[0] * pad + res


def b58_decode(s):
    if not s:
        return b''

    # Convert the string to an integer
    n = 0
    for c in s:
        n *= 58
        if c not in b58_digits:
            raise InvalidBase58Error('Character %r is not a ' +
                                     'valid base58 character' % c)
        digit = b58_digits.index(c)
        n += digit

    # Convert the integer to bytes
    h = '%x' % n
    if len(h) % 2:
        h = '0' + h
    res = encoding.HexEncoder.decode(h.encode('utf8'))

    # Add padding back.
    pad = 0
    for c in s[:-1]:
        if c == b58_digits[0]:
            pad += 1
        else:
            break
    return b'\x00' * pad + res


def xor_bytes(b1, b2):
    result = bytearray()
    for b1, b2 in zip(b1, b2):
        result.append(b1 ^ b2)
    return result


def message_exit(message):
    print(message)
    exit(1)