#!/usr/bin/env python

import enum
import itertools
import json
import os
import re
import sys
from dataclasses import KW_ONLY, dataclass, field
from functools import partial, partialmethod
from operator import itemgetter
from time import sleep

import defl
from defl import CLIError, DotDict, Null, Path, Undefined, cl, log
from defl._assert_ import Assert
from defl._typing_ import *
from defl.testing_ import Tester

tester = Tester(name=__file__)

@tester.add()
def dotDictTest():
    print()
    DotDict()
    a = DotDict({"b": {"c": {"d": "e"}}})
    assert isinstance(a, DotDict), type(a)
    assert isinstance(a["b"], DotDict), type(a["b"])
    assert isinstance(a["b"]['c'], DotDict), type(a["b"]['c'])
    assert a.get('z') is None, a.get('z')
    assert isinstance(a.get('b'), DotDict), a.get('b')
    assert isinstance(a.b, DotDict), type(a.b)
    assert isinstance(a.b.c, DotDict), type(a.b.c)
    assert isinstance(a.b.c.d, str), type(a.b.c.d)

    a.b['c'] = 1
    assert a.b.c == 1
    assert a.b['c'] == 1

    a.b.d = 2
    assert a.b.d == 2
    assert a.b['d'] == 2

    del a.b.d
    assert a.b.get('d', -9) == -9

    a.g = {'k': {'v': 'q'}}
    assert isinstance(a.g, DotDict), type(a.g)

    d = json.dumps(a, sort_keys=True)
    assert d == '{"b": {"c": 1}, "g": {"k": {"v": "q"}}}', d

    a = DotDict({"b": [{'a': 'b'}, {'a': 'b'}, 2]})
    assert isinstance(a.b[0], DotDict)
    assert isinstance(a.b[1], DotDict)
    assert isinstance(a.b[2], int)
    assert isinstance(a, DotDict)
    assert isinstance(a.b, list)

@tester.add()
def chunk():
    assert defl.chunkRange(0, 5, chunks=1) == [(0, 4)]
    assert defl.chunkRange(0, 5, chunkSize=1) == [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]
    assert defl.chunkRange(0, 5, chunks=2) == [(0, 2), (3, 4)]
    assert defl.chunkRange(0, 5, chunkSize=2) == [(0, 1), (2, 3), (4, 4)]

@tester.add()
def rniy():
    d = {1: 1}
    a = [[1], [2, [3, [4], (5, set([6]), '7')]], d]
    a = [x for x in defl.recursiveNonIterableYield(a)]
    b = [1, 2, 3, 4, 5, 6, '7', d]
    assert a == b, (a, b)

    a = a[:-1]
    a = [x for x in defl.recursiveNonIterableYield(a, oper=int)]
    b = [1, 2, 3, 4, 5, 6, 7]
    assert a == b, (a, b)

@tester.add()
def listFromArgsStar():
    Assert(defl.listFromArgsStar(1, 2, 3, 4)).eq([1, 2, 3, 4])
    Assert(defl.listFromArgsStar([1, 2, 3, 4])).eq([1, 2, 3, 4])
    Assert(defl.listFromArgsStar([1])).eq([1])
    Assert(defl.listFromArgsStar(1)).eq([1])
    Assert(defl.listFromArgsStar()).eq(list())

@tester.add()
def listFromArgsStar():
    assert (1 == 2 == False) == False
    assert ((1 == 2) == False) == True

# @tester.add()
def retainProperyReference():
    import weakref

    @dataclass(slots=T, kw_only=T, frozen=F)
    class A:
        i: ClassVar[int] = 0

        @property
        def b(_) -> int:
            _.i = _.i + 1
            return _.i

    class B():
        __call__ = None

    a = A()
    b = B()
    b.__call__ = lambda: 1
    print(b)
    # <__main__.retainProperyReference.<locals>.B object at 0x7517276fa300>

    assert b == 1, b

@tester.add()
def listFromArgsStar():
    a = [[1]]
    b = defl.listFromArgsStar(a)
    if len(a) == 1 and inst(a, list | tuple):
        c = a[0]
    assert a == b

    Assert(defl.listFromArgsStar('python - import -p a')).eq(['python - import -p a'])

@tester.add()
def listFromArgsStar():
    from ctypes import c_bool
    c_bool('test')

@tester.add()
def testStackLocalValue():
    def a():
        dog = T
        return b()

    def b():
        return c()

    def c():
        return d()

    def d():
        return defl.stackLocalValue(leaf='dog')

    Assert(a()) == T

@tester.add()
def testStackLocalValue():
    def a():
        dog = T
        return b()

    def b():
        return c()

    def c():
        return d()

    def d():
        return defl.stackLocalValue(leaf='dog', stem='cat')

    Assert(a()) == N

@tester.add()
def testStackLocalValue():
    def a():
        dog = T
        return b()

    def b():
        cat = T
        return c()

    def c():
        cat = T
        return d()

    def d():
        return defl.stackLocalValue(leaf='dog', stem='cat')

    Assert(a()) == T

log.info(tester.run())
tester.exitWithStatus()

# for i in ch:
#     print(defl.printTable([[y for y in x] for x in ch], squareFill=True))