#!/usr/bin/env python

from dataclasses import dataclass, field
import sys, re, os, enum, itertools
from functools import partial, partialmethod
from time import sleep
from subprocess import Popen, PIPE, DEVNULL
from operator import itemgetter
from defl import log, cl, Path, Undefined, Null, Assert, Time, Obj, Dunder, IterableType, isIterableType, Run
from defl import CLIError
from defl._typing_ import *
import defl
import defl
from defl import log, cl, Assert
from defl.sheet_ import Sheet
from defl.testing_ import Tester, Test, TestState

tester = Tester(name=__file__)

@tester.add()
def getSet():
    d = {'a': [1, 2, 3], 'b': (1.1, 2.2, 3.3), 'c': ['cat', 'dog', 'frog']}
    s = Sheet(d)
    slic = s['a', 'b']
    Assert(slic) == {'a': [1, 2, 3], 'b': (1.1, 2.2, 3.3)}
    s['a', 'b'] = {'a': [4, 5, 6], 'b': (4.4, 5.5, 6.6)}
    Assert(s.toDict()) == {'a': [4, 5, 6], 'b': (4.4, 5.5, 6.6), 'c': ['cat', 'dog', 'frog']}
    s[('a', )] = [[5, 6, 7]]
    Assert(s.toDict()) == {'a': [5, 6, 7], 'b': (4.4, 5.5, 6.6), 'c': ['cat', 'dog', 'frog']}
    s['a'] = [8, 9, 10]
    Assert(s.toDict()) == {'a': [8, 9, 10], 'b': (4.4, 5.5, 6.6), 'c': ['cat', 'dog', 'frog']}
    s.r('a')[1] = 5
    Assert(s.toDict()) == {'a': [8, 5, 10], 'b': (4.4, 5.5, 6.6), 'c': ['cat', 'dog', 'frog']}

    s = Sheet({'a': [1, 2, 3], 'b': [4, 5, 6], 'c': [7, 8, 9]})
    s['b', 'c'] = Sheet({'z': [5, 5, 5], 'y': [7, 7, 7]})
    Assert(s.d) == {'a': [1, 2, 3], 'b': [5, 5, 5], 'c': [7, 7, 7]}

    s = Sheet({'a': [1, 2, 3], 'b': [4, 5, 6], 'c': [7, 8, 9]})
    s['b', 'c'] = Sheet([[5, 5, 5], [7, 7, 7]])
    Assert(s.d) == {'a': [1, 2, 3], 'b': [5, 5, 5], 'c': [7, 7, 7]}

@tester.add()
def map():
    s = Sheet({'a': [1, 2, 3], 'b': [4, 5, 6], 'c': [7, 8, 9]})
    s['d'] = s.map['a', 'b'](lambda a, b: a * b)
    Assert(s['d'].d) == {'d': [4, 10, 18]}
    Assert(s.r('d')) == [4, 10, 18]
    Assert(s['d'].d['d']) == [4, 10, 18]

@tester.add()
def rows():
    s = Sheet({'a': [1, 2, 3], 'b': [4, 5, 6], 'c': [7, 8, 9]})
    Assert([x for x in s]) == [{'a': 1, 'b': 4, 'c': 7}, {'a': 2, 'b': 5, 'c': 8}, {'a': 3, 'b': 6, 'c': 9}]
    Assert(s.mapRow(lambda x: x['a'] * x['c'] - x['b'])) == [3, 11, 21]

@tester.add()
def mangle():
    s = Sheet({'a': [1, 2, 3], 'b': [4, 5, 6], 'c': [7, 8, 9]})
    Assert(s.toDict()) == {'a': [1, 2, 3], 'b': [4, 5, 6], 'c': [7, 8, 9]}

@tester.add()
def sort():
    s = Sheet({'a': [1, 2, 3], 'b': [6, 5, 4], 'c': [7, 8, 9]})
    sort = s.sort(lambda x: x['b'])
    Assert(sort.d) == {'a': [3, 2, 1], 'b': [4, 5, 6], 'c': [9, 8, 7]}

@tester.add()
def init():
    s1 = Sheet({'a': [1, 2, 3], 'b': [6, 5, 4], 'c': [7, 8, 9]})
    Assert(Sheet([x for x in s1])) == s1

    s2 = Sheet({'a': [1, 2, 3], 'b': [6, 5, 4], 'c': [7, 8, 9]})
    Assert(Sheet([x for x in s2])) == s1

    s2.r('a')[1] = 5
    Assert(Sheet([x for x in s2])) != s1

@tester.add()
def filter():
    s1 = Sheet({'a': [1, 2, 3], 'b': [6, 5, 4], 'c': [7, 8, 9]})
    Assert(s1.filter(lambda x: x.a > 1 and x.c < 9).d) == {'a': [2], 'b': [5], 'c': [8]}

@tester.add()
def string():
    s1 = Sheet({'a': [1, 22, 333], 'bbbb': [66666, 5555555, 4], 'c': [7, 8, 9]})
    log.info(s1)
    Assert(s1.str()) == '[a]    [bbbb] [c]\n  1    66,666   7\n 22 5,555,555   8\n333         4   9'

    s2 = Sheet({'a': [11, 2.22, 3.33], 'b': (1.12345, 2.23456, 3.34567)})
    log.info(s2)
    Assert(s2.str()) == '  [a]  [b]\n11.00 1.12\n 2.22 2.23\n 3.33 3.35'

    s2 = Sheet({'a': ['zdada', 'b', 'b'], 'b': (1.12345, 2.23456, 3.34567)})
    log.info(s2)
    Assert(s2.str()) == "[a]    [b]\nzdada 1.12\nb     2.23\nb     3.35"

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