# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.
from __future__ import annotations

# System Imports
import copyreg
import io
import pickle
import sys
import textwrap
from typing import Any, Callable, NoReturn

from typing_extensions import TypeAlias

# Twisted Imports
from twisted.persisted import aot, crefutil, styles
from twisted.trial import unittest
from twisted.trial.unittest import TestCase


class VersionTests(TestCase):
    def test_nullVersionUpgrade(self) -> None:
        global NullVersioned

        class NullVersioned:
            def __init__(self) -> None:
                self.ok = 0

        pkcl = pickle.dumps(NullVersioned())

        class NullVersioned(styles.Versioned):  # type: ignore[no-redef]
            persistenceVersion = 1

            def upgradeToVersion1(self) -> None:
                self.ok = 1

        mnv = pickle.loads(pkcl)
        styles.doUpgrade()
        assert mnv.ok, "initial upgrade not run!"

    def test_versionUpgrade(self) -> None:
        global MyVersioned

        class MyVersioned(styles.Versioned):
            persistenceVersion = 2
            # persistenceForgets should be a tuple
            persistenceForgets = ["garbagedata"]  # type: ignore[assignment]
            v3 = 0
            v4 = 0

            def __init__(self) -> None:
                self.somedata = "xxx"
                self.garbagedata = lambda q: "cant persist"

            def upgradeToVersion3(self) -> None:
                self.v3 += 1

            def upgradeToVersion4(self) -> None:
                self.v4 += 1

        mv = MyVersioned()
        assert not (mv.v3 or mv.v4), "hasn't been upgraded yet"
        pickl = pickle.dumps(mv)
        MyVersioned.persistenceVersion = 4
        obj = pickle.loads(pickl)
        styles.doUpgrade()
        assert obj.v3, "didn't do version 3 upgrade"
        assert obj.v4, "didn't do version 4 upgrade"
        pickl = pickle.dumps(obj)
        obj = pickle.loads(pickl)
        styles.doUpgrade()
        assert obj.v3 == 1, "upgraded unnecessarily"
        assert obj.v4 == 1, "upgraded unnecessarily"

    def test_nonIdentityHash(self) -> None:
        global ClassWithCustomHash

        class ClassWithCustomHash(styles.Versioned):
            def __init__(self, unique: str, hash: int) -> None:
                self.unique = unique
                self.hash = hash

            def __hash__(self) -> int:
                return self.hash

        v1 = ClassWithCustomHash("v1", 0)
        v2 = ClassWithCustomHash("v2", 0)

        pkl = pickle.dumps((v1, v2))
        del v1, v2
        ClassWithCustomHash.persistenceVersion = 1
        ClassWithCustomHash.upgradeToVersion1 = lambda self: setattr(  # type: ignore[attr-defined]
            self, "upgraded", True
        )
        v1, v2 = pickle.loads(pkl)
        styles.doUpgrade()
        self.assertEqual(v1.unique, "v1")
        self.assertEqual(v2.unique, "v2")
        self.assertTrue(v1.upgraded)
        self.assertTrue(v2.upgraded)

    def test_upgradeDeserializesObjectsRequiringUpgrade(self) -> None:
        global ToyClassA, ToyClassB

        class ToyClassA(styles.Versioned):
            pass

        class ToyClassB(styles.Versioned):
            pass

        x = ToyClassA()
        y = ToyClassB()
        pklA, pklB = pickle.dumps(x), pickle.dumps(y)
        del x, y
        ToyClassA.persistenceVersion = 1

        def upgradeToVersion1(self: Any) -> None:
            self.y = pickle.loads(pklB)
            styles.doUpgrade()

        ToyClassA.upgradeToVersion1 = upgradeToVersion1  # type: ignore[attr-defined]
        ToyClassB.persistenceVersion = 1

        def setUpgraded(self: object) -> None:
            setattr(self, "upgraded", True)

        ToyClassB.upgradeToVersion1 = setUpgraded  # type: ignore[attr-defined]

        x = pickle.loads(pklA)
        styles.doUpgrade()
        self.assertTrue(x.y.upgraded)


class VersionedSubClass(styles.Versioned):
    pass


class SecondVersionedSubClass(styles.Versioned):
    pass


class VersionedSubSubClass(VersionedSubClass):
    pass


class VersionedDiamondSubClass(VersionedSubSubClass, SecondVersionedSubClass):
    pass


class AybabtuTests(TestCase):
    """
    L{styles._aybabtu} gets all of classes in the inheritance hierarchy of its
    argument that are strictly between L{Versioned} and the class itself.
    """

    def test_aybabtuStrictEmpty(self) -> None:
        """
        L{styles._aybabtu} of L{Versioned} itself is an empty list.
        """
        self.assertEqual(styles._aybabtu(styles.Versioned), [])

    def test_aybabtuStrictSubclass(self) -> None:
        """
        There are no classes I{between} L{VersionedSubClass} and L{Versioned},
        so L{styles._aybabtu} returns an empty list.
        """
        self.assertEqual(styles._aybabtu(VersionedSubClass), [])

    def test_aybabtuSubsubclass(self) -> None:
        """
        With a sub-sub-class of L{Versioned}, L{styles._aybabtu} returns a list
        containing the intervening subclass.
        """
        self.assertEqual(styles._aybabtu(VersionedSubSubClass), [VersionedSubClass])

    def test_aybabtuStrict(self) -> None:
        """
        For a diamond-shaped inheritance graph, L{styles._aybabtu} returns a
        list containing I{both} intermediate subclasses.
        """
        self.assertEqual(
            styles._aybabtu(VersionedDiamondSubClass),
            [VersionedSubSubClass, VersionedSubClass, SecondVersionedSubClass],
        )


class MyEphemeral(styles.Ephemeral):
    def __init__(self, x: int) -> None:
        self.x = x


class EphemeralTests(TestCase):
    def test_ephemeral(self) -> None:
        o = MyEphemeral(3)
        self.assertEqual(o.__class__, MyEphemeral)
        self.assertEqual(o.x, 3)

        pickl = pickle.dumps(o)
        o = pickle.loads(pickl)

        self.assertEqual(o.__class__, styles.Ephemeral)
        self.assertFalse(hasattr(o, "x"))


class Pickleable:
    def __init__(self, x: int) -> None:
        self.x = x

    def getX(self) -> int:
        return self.x


class NotPickleable:
    """
    A class that is not pickleable.
    """

    def __reduce__(self) -> NoReturn:
        """
        Raise an exception instead of pickling.
        """
        raise TypeError("Not serializable.")


class CopyRegistered:
    """
    A class that is pickleable only because it is registered with the
    C{copyreg} module.
    """

    def __init__(self) -> None:
        """
        Ensure that this object is normally not pickleable.
        """
        self.notPickleable = NotPickleable()


class CopyRegisteredLoaded:
    """
    L{CopyRegistered} after unserialization.
    """


def reduceCopyRegistered(cr: object) -> tuple[type[CopyRegisteredLoaded], tuple[()]]:
    """
    Externally implement C{__reduce__} for L{CopyRegistered}.

    @param cr: The L{CopyRegistered} instance.

    @return: a 2-tuple of callable and argument list, in this case
        L{CopyRegisteredLoaded} and no arguments.
    """
    return CopyRegisteredLoaded, ()


copyreg.pickle(CopyRegistered, reduceCopyRegistered)  # type: ignore[arg-type]


class A:
    """
    dummy class
    """

    bmethod: Callable[[], None]

    def amethod(self) -> None:
        pass


class B:
    """
    dummy class
    """

    a: A

    def bmethod(self) -> None:
        pass


def funktion() -> None:
    pass


class PicklingTests(TestCase):
    """Test pickling of extra object types."""

    def test_module(self) -> None:
        pickl = pickle.dumps(styles)
        o = pickle.loads(pickl)
        self.assertEqual(o, styles)

    def test_instanceMethod(self) -> None:
        obj = Pickleable(4)
        pickl = pickle.dumps(obj.getX)
        o = pickle.loads(pickl)
        self.assertEqual(o(), 4)
        self.assertEqual(type(o), type(obj.getX))


class StringIOTransitionTests(TestCase):
    """
    When pickling a cStringIO in Python 2, it should unpickle as a BytesIO or a
    StringIO in Python 3, depending on the type of its contents.
    """

    def test_unpickleBytesIO(self) -> None:
        """
        A cStringIO pickled with bytes in it will yield an L{io.BytesIO} on
        python 3.
        """
        pickledStringIWithText = (
            b"ctwisted.persisted.styles\nunpickleStringI\np0\n"
            b"(S'test'\np1\nI0\ntp2\nRp3\n."
        )
        loaded = pickle.loads(pickledStringIWithText)
        self.assertIsInstance(loaded, io.StringIO)
        self.assertEqual(loaded.getvalue(), "test")


class EvilSourceror:
    a: EvilSourceror
    b: EvilSourceror
    c: object

    def __init__(self, x: object) -> None:
        self.a = self
        self.a.b = self
        self.a.b.c = x


class NonDictState:
    state: str

    def __getstate__(self) -> str:
        return self.state

    def __setstate__(self, state: str) -> None:
        self.state = state


_CircularTupleType: TypeAlias = list[tuple["_CircularTupleType", int]]


class AOTTests(TestCase):
    def test_simpleTypes(self) -> None:
        obj = (
            1,
            2.0,
            3j,
            True,
            slice(1, 2, 3),
            "hello",
            "world",
            sys.maxsize + 1,
            None,
            Ellipsis,
        )
        rtObj = aot.unjellyFromSource(aot.jellyToSource(obj))
        self.assertEqual(obj, rtObj)

    def test_methodSelfIdentity(self) -> None:
        a = A()
        b = B()
        a.bmethod = b.bmethod
        b.a = a
        im_ = aot.unjellyFromSource(aot.jellyToSource(b)).a.bmethod
        self.assertEqual(aot._selfOfMethod(im_).__class__, aot._classOfMethod(im_))

    def test_methodNotSelfIdentity(self) -> None:
        """
        If a class change after an instance has been created,
        L{aot.unjellyFromSource} shoud raise a C{TypeError} when trying to
        unjelly the instance.
        """
        a = A()
        b = B()
        a.bmethod = b.bmethod
        b.a = a
        savedbmethod = B.bmethod
        del B.bmethod
        try:
            self.assertRaises(TypeError, aot.unjellyFromSource, aot.jellyToSource(b))
        finally:
            B.bmethod = savedbmethod  # type: ignore[method-assign]

    def test_unsupportedType(self) -> None:
        """
        L{aot.jellyToSource} should raise a C{TypeError} when trying to jelly
        an unknown type without a C{__dict__} property or C{__getstate__}
        method.
        """

        class UnknownType:
            @property
            def __dict__(self) -> NoReturn:  # type: ignore[override]
                raise AttributeError()

            @property
            def __getstate__(self) -> NoReturn:
                raise AttributeError()

        self.assertRaises(TypeError, aot.jellyToSource, UnknownType())

    def test_basicIdentity(self) -> None:
        # Anyone wanting to make this datastructure more complex, and thus this
        # test more comprehensive, is welcome to do so.
        aj = aot.AOTJellier().jellyToAO
        d = {"hello": "world", "method": aj}
        l = [
            1,
            2,
            3,
            'he\tllo\n\n"x world!',
            "goodbye \n\t\u1010 world!",
            1,
            1.0,
            100**100,
            unittest,
            aot.AOTJellier,
            d,
            funktion,
        ]
        t = tuple(l)
        l.append(l)
        l.append(t)
        l.append(t)
        uj = aot.unjellyFromSource(aot.jellyToSource([l, l]))
        assert uj[0] is uj[1]
        assert uj[1][0:5] == l[0:5]

    def test_nonDictState(self) -> None:
        a = NonDictState()
        a.state = "meringue!"
        assert aot.unjellyFromSource(aot.jellyToSource(a)).state == a.state

    def test_copyReg(self) -> None:
        """
        L{aot.jellyToSource} and L{aot.unjellyFromSource} honor functions
        registered in the pickle copy registry.
        """
        uj = aot.unjellyFromSource(aot.jellyToSource(CopyRegistered()))
        self.assertIsInstance(uj, CopyRegisteredLoaded)

    def test_funkyReferences(self) -> None:
        o = EvilSourceror(EvilSourceror([]))
        j1 = aot.jellyToAOT(o)
        oj = aot.unjellyFromAOT(j1)

        assert oj.a is oj
        assert oj.a.b is oj.b
        assert oj.c is not oj.c.c

    def test_circularTuple(self) -> None:
        """
        L{aot.jellyToAOT} can persist circular references through tuples.
        """
        l: _CircularTupleType = []
        t = (l, 4321)
        l.append(t)
        j1 = aot.jellyToAOT(l)
        oj = aot.unjellyFromAOT(j1)
        self.assertIsInstance(oj[0], tuple)
        self.assertIs(oj[0][0], oj)
        self.assertEqual(oj[0][1], 4321)

    def testIndentify(self) -> None:
        """
        The generated serialization is indented.
        """
        self.assertEqual(
            aot.jellyToSource({"hello": {"world": []}}),
            textwrap.dedent(
                """\
                app={
                  'hello':{
                    'world':[],
                    },
                  }""",
            ),
        )


class CrefUtilTests(TestCase):
    """
    Tests for L{crefutil}.
    """

    def test_dictUnknownKey(self) -> None:
        """
        L{crefutil._DictKeyAndValue} only support keys C{0} and C{1}.
        """
        d = crefutil._DictKeyAndValue({})
        self.assertRaises(RuntimeError, d.__setitem__, 2, 3)

    def test_deferSetMultipleTimes(self) -> None:
        """
        L{crefutil._Defer} can be assigned a key only one time.
        """
        d = crefutil._Defer()
        d[0] = 1
        self.assertRaises(RuntimeError, d.__setitem__, 0, 1)

    def test_containerWhereAllElementsAreKnown(self) -> None:
        """
        A L{crefutil._Container} where all of its elements are known at
        construction time is nonsensical and will result in errors in any call
        to addDependant.
        """
        container = crefutil._Container([1, 2, 3], list)
        self.assertRaises(AssertionError, container.addDependant, {}, "ignore-me")

    def test_dontPutCircularReferencesInDictionaryKeys(self) -> None:
        """
        If a dictionary key contains a circular reference (which is probably a
        bad practice anyway) it will be resolved by a
        L{crefutil._DictKeyAndValue}, not by placing a L{crefutil.NotKnown}
        into a dictionary key.
        """
        self.assertRaises(
            AssertionError, dict().__setitem__, crefutil.NotKnown(), "value"
        )

    def test_dontCallInstanceMethodsThatArentReady(self) -> None:
        """
        L{crefutil._InstanceMethod} raises L{AssertionError} to indicate it
        should not be called.  This should not be possible with any of its API
        clients, but is provided for helping to debug.
        """
        self.assertRaises(
            AssertionError,
            crefutil._InstanceMethod("no_name", crefutil.NotKnown(), type),
        )


testCases = [VersionTests, EphemeralTests, PicklingTests]
