import pytest
import unittest

from monero import const
from monero.address import Address, SubAddress, IntegratedAddress, address
from tests.utils import classproperty


class Tests(object):
    @classproperty
    def __test__(cls):
        return issubclass(cls, unittest.TestCase)

    def test_from_and_to_string(self):
        a = Address(self.addr)
        self.assertEqual(str(a), self.addr)
        self.assertEqual("{:s}".format(a), self.addr)
        self.assertEqual(a.spend_key(), self.psk)
        self.assertEqual(a.view_key(), self.pvk)
        self.assertEqual(hash(a), hash(self.addr))
        ba = Address(self.addr.encode())
        self.assertEqual(ba, a)
        ba = address(self.addr.encode())
        self.assertEqual(ba, a)

        ia = IntegratedAddress(self.iaddr)
        self.assertEqual(ia.payment_id(), self.pid)
        self.assertEqual(str(ia), self.iaddr)
        self.assertEqual("{:s}".format(ia), self.iaddr)
        self.assertEqual(ia.spend_key(), self.psk)
        self.assertEqual(ia.view_key(), self.pvk)
        self.assertEqual(ia.base_address(), a)
        ba = IntegratedAddress(self.iaddr.encode())
        self.assertEqual(ba, ia)
        ba = address(self.iaddr.encode())
        self.assertEqual(ba, ia)

        sa = SubAddress(self.subaddr)
        self.assertEqual(str(sa), self.subaddr)
        self.assertEqual("{:s}".format(sa), self.subaddr)
        ba = SubAddress(self.subaddr.encode())
        self.assertEqual(ba, sa)
        ba = address(self.subaddr.encode())
        self.assertEqual(ba, sa)

    def test_payment_id(self):
        a = Address(self.addr)
        ia = a.with_payment_id(self.pid)
        self.assertIsInstance(ia, IntegratedAddress)
        self.assertEqual(ia.payment_id(), self.pid)
        self.assertEqual(str(ia), self.iaddr)

    @pytest.mark.filterwarnings("ignore::DeprecationWarning")
    def test_recognition_and_comparisons(self):
        a = Address(self.addr)
        a2 = address(self.addr)
        self.assertIsInstance(a2, Address)
        self.assertEqual(a, a2)
        self.assertEqual(a, self.addr)
        self.assertEqual(self.addr, a)
        self.assertEqual(hash(a), hash(self.addr))
        self.assertEqual(a.net, self.net)
        with pytest.deprecated_call():
            self.assertEqual(a.is_mainnet(), self.net == const.NET_MAIN)
        with pytest.deprecated_call():
            self.assertEqual(a.is_testnet(), self.net == const.NET_TEST)
        with pytest.deprecated_call():
            self.assertEqual(a.is_stagenet(), self.net == const.NET_STAGE)
        self.assertEqual(a2.net, self.net)
        with pytest.deprecated_call():
            self.assertEqual(a2.is_mainnet(), self.net == const.NET_MAIN)
        with pytest.deprecated_call():
            self.assertEqual(a2.is_testnet(), self.net == const.NET_TEST)
        with pytest.deprecated_call():
            self.assertEqual(a2.is_stagenet(), self.net == const.NET_STAGE)

        ia = IntegratedAddress(self.iaddr)
        ia2 = address(self.iaddr)
        self.assertIsInstance(ia, IntegratedAddress)
        self.assertEqual(ia, ia2)
        self.assertEqual(ia, self.iaddr)
        self.assertEqual(self.iaddr, ia)
        self.assertEqual(hash(ia), hash(self.iaddr))
        self.assertEqual(ia.net, self.net)
        with pytest.deprecated_call():
            self.assertEqual(ia.is_mainnet(), self.net == const.NET_MAIN)
        with pytest.deprecated_call():
            self.assertEqual(ia.is_testnet(), self.net == const.NET_TEST)
        with pytest.deprecated_call():
            self.assertEqual(ia.is_stagenet(), self.net == const.NET_STAGE)
        self.assertEqual(ia2.net, self.net)
        with pytest.deprecated_call():
            self.assertEqual(ia2.is_mainnet(), self.net == const.NET_MAIN)
        with pytest.deprecated_call():
            self.assertEqual(ia2.is_testnet(), self.net == const.NET_TEST)
        with pytest.deprecated_call():
            self.assertEqual(ia2.is_stagenet(), self.net == const.NET_STAGE)
        self.assertEqual(ia2.base_address(), a)

        self.assertEqual(ia.view_key(), a.view_key())
        self.assertEqual(ia.spend_key(), a.spend_key())

        sa = SubAddress(self.subaddr)
        sa2 = address(self.subaddr)
        self.assertIsInstance(sa2, SubAddress)
        self.assertEqual(sa, sa2)
        self.assertEqual(sa, self.subaddr)
        self.assertEqual(self.subaddr, sa)
        self.assertEqual(hash(sa), hash(self.subaddr))
        self.assertEqual(sa.net, self.net)
        with pytest.deprecated_call():
            self.assertEqual(sa.is_mainnet(), self.net == const.NET_MAIN)
        with pytest.deprecated_call():
            self.assertEqual(sa.is_testnet(), self.net == const.NET_TEST)
        with pytest.deprecated_call():
            self.assertEqual(sa.is_stagenet(), self.net == const.NET_STAGE)
        self.assertEqual(sa2.net, self.net)
        with pytest.deprecated_call():
            self.assertEqual(sa2.is_mainnet(), self.net == const.NET_MAIN)
        with pytest.deprecated_call():
            self.assertEqual(sa2.is_testnet(), self.net == const.NET_TEST)
        with pytest.deprecated_call():
            self.assertEqual(sa2.is_stagenet(), self.net == const.NET_STAGE)

        self.assertNotEqual(a, 0)

    def test_check_private_view_key(self):
        a = Address(self.addr)
        self.assertFalse(a.check_private_view_key(self.ssk))
        self.assertTrue(a.check_private_view_key(self.svk))
        self.assertFalse(a.check_private_view_key(self.psk))
        self.assertFalse(a.check_private_view_key(self.pvk))
        self.assertFalse(a.check_private_view_key('0000000000000000000000000000000000000000000000000000000000000000'))

    def test_check_private_spend_key(self):
        a = Address(self.addr)
        self.assertTrue(a.check_private_spend_key(self.ssk))
        self.assertFalse(a.check_private_spend_key(self.svk))
        self.assertFalse(a.check_private_spend_key(self.psk))
        self.assertFalse(a.check_private_spend_key(self.pvk))
        self.assertFalse(a.check_private_spend_key('0000000000000000000000000000000000000000000000000000000000000000'))

    def test_idempotence(self):
        a = Address(self.addr)
        a_idem = Address(a)
        self.assertEqual(a, a_idem)
        a_idem = Address(str(a))
        self.assertEqual(a, a_idem)
        a_idem = address(a)
        self.assertEqual(a, a_idem)

        ia = IntegratedAddress(self.iaddr)
        ia_idem = IntegratedAddress(ia)
        self.assertEqual(ia, ia_idem)
        ia_idem = IntegratedAddress(str(ia))
        self.assertEqual(ia, ia_idem)
        ia_idem = address(ia)
        self.assertEqual(ia, ia_idem)

    def test_invalid(self):
        self.assertRaises(ValueError, Address, self.addr_invalid)
        self.assertRaises(ValueError, Address, self.iaddr_invalid)
        a = Address(self.addr)
        self.assertRaises(TypeError, a.with_payment_id, 2**64+1)
        self.assertRaises(TypeError, a.with_payment_id, "%x" % (2**64+1))
        s = SubAddress(self.subaddr)
        self.assertRaises(TypeError, s.with_payment_id, 0)
        self.assertRaises(ValueError, address, 'whatever')
        self.assertRaises(ValueError, Address, 'whatever')
        self.assertRaises(ValueError, SubAddress, 'whatever')
        self.assertRaises(ValueError, IntegratedAddress, 'whatever')
        # Aeon
        self.assertRaises(
            ValueError,
            address,
            'Wmtj8UAJhdrhbKvwyBJmLEUZKHcffv2VHNBaq6oTxJFwJjUj3QwMUSS32mddSX7vchbxXdmb4QuZA9TsN47441f61yAYLQYTo')
        # invalid netbyte
        self.assertRaises(
            ValueError,
            address,
            'Cf6RinMUztY5otm6NEFjg3UWBBkXK6Lh23wKrLFMEcCY7i3A6aPLH9i4QMCkf6CdWk8Q9N7yoJf7ANKgtQMuPM6JANXgCWs')

    def test_type_mismatch(self):
        self.assertRaises(ValueError, Address, self.iaddr)
        self.assertRaises(ValueError, Address, self.subaddr)
        self.assertRaises(ValueError, IntegratedAddress, self.addr)
        self.assertRaises(ValueError, IntegratedAddress, self.subaddr)
        self.assertRaises(ValueError, SubAddress, self.addr)
        self.assertRaises(ValueError, SubAddress, self.iaddr)

    def test_subaddress_cannot_into_integrated(self):
        sa = SubAddress(self.subaddr)
        self.assertRaises(TypeError, sa.with_payment_id, self.pid)


class AddressTestCase(Tests, unittest.TestCase):
    addr = '47ewoP19TN7JEEnFKUJHAYhGxkeTRH82sf36giEp9AcNfDBfkAtRLX7A6rZz18bbNHPNV7ex6WYbMN3aKisFRJZ8Ebsmgef'
    ssk = 'e0fe01d5794e240a26609250c0d7e01673219eececa3f499d5cfa20a75739b0a'
    svk = '6d9056aa2c096bfcd2f272759555e5764ba204dd362604a983fa3e0aafd35901'
    psk = '9f2a76d879aaf0670039dc8dbdca01f0ca26a2f6d93268e3674666bfdc5957e4'
    pvk = '716cfc7da7e6ce366935c55747839a85be798037ab189c7dd0f10b7f1690cb78'
    pid = '4a6f686e47616c74'
    iaddr = '4HMcpBpe4ddJEEnFKUJHAYhGxkeTRH82sf36giEp9AcNfDBfkAtRLX7A6rZz18bbNHPNV7ex6WYbMN3aKisFRJZ8M7yKhzQhKW3ECCLWQw'
    subaddr = '84LooD7i35SFppgf4tQ453Vi3q5WexSUXaVgut69ro8MFnmHwuezAArEZTZyLr9fS6QotjqkSAxSF6d1aDgsPoX849izJ7m'
    net = const.NET_MAIN
    addr_invalid = '47ewoP19TN7JCEnFKUJHAYhGxkeTRH82sf36giEp9AcNfDBfkAtRLX7A6rZz18bbNHPNV7ex6WYbMN3aKisFRJZ8Ebsmgef'
    iaddr_invalid = '4HMcpBpe4ddJEEnFKUJHAYhGxkyTRH82sf36giEp9AcNfDBfkAtRLX7A6rZz18bbNHPNV7ex6WYbMN3aKisFRJZ8M7yKhzQhKW3ECCLWQw'


class TestnetAddressTestCase(Tests, unittest.TestCase):
    addr = '9wuKTHsxGiwEsMp2fYzJiVahyhU2aZi1oZ6R6fK5U64uRa1Pxi8diZh2S1GJFqYXRRhcbfzfWiPD819zKEZkXTMwP7hMs5N'
    ssk = '4f5b7af2c1942067ba33d34318b9735cb46ab5d50b75294844c82a9dd872c201'
    svk = '60cf228f2bf7f6a70643afe9468fde254145dbd3aab4072ede14bf8bae914103'
    psk = '7cf743dcfd23d452e9b2936caeb622c9849f1ff1ddfd62bfdfac64113c1a4e92'
    pvk = 'e3924b14d99a9c088e5a45278d5218f2d053b1c03c480f00ed2ee3dce80806c4'
    pid = '4a6f686e47616c74'
    subaddr = 'BaU3yLuDqdcETYzeF7vFSVEKNR4sSGxBV1Evrw5yNBf2VMiuAwfDmiF3RHqLHkaA5A6RGiNNRUqvtaqhMtdjA1SQ1tnQV8D'
    iaddr = 'A7bzU6hSszTEsMp2fYzJiVahyhU2aZi1oZ6R6fK5U64uRa1Pxi8diZh2S1GJFqYXRRhcbfzfWiPD819zKEZkXTMwZqGSmLeBXqMEBnZVkh'
    net = const.NET_TEST
    addr_invalid = '9wuKTHsxGiwEsMp3fYzJiVahyhU2aZi1oZ6R6fK5U64uRa1Pxi8diZh2S1GJFqYXRRhcbfzfWiPD819zKEZkXTMwP7hMs5N'
    iaddr_invalid = 'A7bzU6hSszTEsMp2fYzJiVahyhU2aZi2oZ6R6fK5U64uRa1Pxi8diZh2S1GJFqYXRRhcbfzfWiPD819zKEZkXTMwZqGSmLeBXqMEBnZVkh'


class StagenetAddressTestCase(Tests, unittest.TestCase):
    addr = '52jzuBBUMty3xPL3JsQxGP74LDuV6E1LS8Zda1PbdqQjGzFmH6N9ep9McbFKMALujVT9S5mKpbEgC5VPhfoAiVj8LdAqbp6'
    ssk = 'a8733c61797115db4ec8a5ce39fb811f81dd4ec163b880526683e059c7e62503'
    svk = 'fd5c0d25f8f994268079a4f7844274dc870a7c2b88fbfc24ba318375e1d9430f'
    psk = '180c1d7bbf7f2e11aa90d0f61bf49024370e01cd54f33f2d36bba0357c9c205f'
    pvk = '94b66a81e646927b3da74392306f789c5024734b4ce6351ad74c4c7d7351b3ad'
    pid = '4a6f686e47616c74'
    subaddr = '7AeQwvrLtPeYoXVPRkEu8oEL7N9wnqHjYKwSvTf6YKbHgYmw6AJMsjggzVLo21egMK9qcoV1mxCTfP4FbaGb7JEMDfpLetk'
    iaddr = '5CSfuyzxyAV3xPL3JsQxGP74LDuV6E1LS8Zda1PbdqQjGzFmH6N9ep9McbFKMALujVT9S5mKpbEgC5VPhfoAiVj8Vz8ySmoqYgTE8dR1yS'
    net = const.NET_STAGE
    addr_invalid = '52jzuBBUMty3xPL3JsQxGP74LDuV6H1LS8Zda1PbdqQjGzFmH6N9ep9McbFKMALujVT9S5mKpbEgC5VPhfoAiVj8LdAqbp6'
    iaddr_invalid = '5CSfuyzxyAV3xPL3JsQxGP74LDuV6E1LS8Zda1PbdqQjGzFmH6N9ep9McbFKMALujVT9S5mKppEgC5VPhfoAiVj8Vz8ySmoqYgTE8dR1yS'


class KnownBugsTest(unittest.TestCase):
    def test_issue27(self):
        addr = '41tjz19p4qc2gudqnwsdrhgcgxud8bgxy84ufe869nyw7ywbxw9s9gqbix7piu9d7qjvbjtrdnbubhcf663ydq3bsxj1brL'
        self.assertRaises(ValueError, Address, addr)
        self.assertRaises(ValueError, SubAddress, addr)
        self.assertRaises(ValueError, IntegratedAddress, addr)
        self.assertRaises(ValueError, address, addr)