from __future__ import annotations
from dataclasses import dataclass
from typing import Optional

from megasniff.deflator import SchemaDeflatorGenerator
from src.megasniff import SchemaInflatorGenerator


def test_basic_deflator():
    class A:
        a: int

        def __init__(self, a: int):
            self.a = a

    class B:
        def __init__(self, b: int):
            self.b = b

    defl = SchemaDeflatorGenerator()
    fn = defl.schema_to_deflator(A)
    a = fn(A(42))

    assert a['a'] == 42

    fnb = defl.schema_to_deflator(B)
    b = fnb(B(11))
    assert len(b) == 0


def test_unions():
    @dataclass
    class A:
        a: int | str

    defl = SchemaDeflatorGenerator()
    fn = defl.schema_to_deflator(A)

    a = fn(A(42))
    assert a['a'] == 42
    a = fn(A('42'))
    assert a['a'] == '42'
    a = fn(A('42a'))
    assert a['a'] == '42a'


def test_dict_body():
    @dataclass
    class A:
        a: dict[str, float]

    defl = SchemaDeflatorGenerator()
    fn = defl.schema_to_deflator(A)

    a = fn(A({'1': 1.1, '2': 2.2}))
    print(a)
    assert a['a']['1'] == 1.1
    assert a['a']['2'] == 2.2


@dataclass
class CircA:
    b: CircB


@dataclass
class CircB:
    a: CircA | None


def test_circular():
    defl = SchemaDeflatorGenerator()
    fn = defl.schema_to_deflator(CircA)
    a = fn(CircA(CircB(CircA(CircB(None)))))

    assert isinstance(a['b'], dict)
    assert isinstance(a['b']['a'], dict)
    assert a['b']['a']['b']['a'] is None


def test_optional():
    @dataclass
    class C:
        a: Optional[int] = None

    defl = SchemaDeflatorGenerator()
    fn = defl.schema_to_deflator(C)
    c = fn(C())
    assert c['a'] is None
    c = fn(C(123))
    assert c['a'] == 123