from solo_turnier import worker
import os
import json
import pytest

def __importJSONData(name):
    path = os.path.join(os.path.dirname(__file__), 'worker', name)
    with open(path, 'r') as fp:
        return json.load(fp)

@pytest.fixture
def fixture_csvExtractor():
    data = __importJSONData('csvImport.json')
    expected = __importJSONData('csvImportResult.json')
    return (data, expected)

def test_csvExtractor(fixture_csvExtractor):
    extractor = worker.CSVExtractor()
    mapped = extractor.mapCSVImport(fixture_csvExtractor[0])

    assert len(mapped) == len(fixture_csvExtractor[1])
    for i,elem in enumerate(fixture_csvExtractor[1]):
        assert mapped[i].__dict__ == elem

def test_extractPersonFromRow():
    row = worker.ResultRow('Max', 'Mustermann', 'TSC Entenhausen', '2', 'Kin', 'Adv.', 'Rumba', '2', '2', 'Kin.', 'Beg./Adv.')
    person = worker.ResultPerson.extractFromResultRow(row)
    expected = {
        'firstName': 'Max',
        'lastName': 'Mustermann',
        'name': 'Max Mustermann',
        'club': 'TSC Entenhausen',
        'id': None,
        'group': None
    }
    assert person.__dict__ == expected

def test_extractCompetitionFromRow():
    row = worker.ResultRow('Max', 'Mustermann', 'TSC Entenhausen', '2', 'Kin', 'Adv.', 'Rumba', '2', '2', 'Kin.', 'Beg./Adv.')
    competition = worker.CompetitionResult.extractFromResultRow(row)
    expected = {
        'dance': 'Rumba',
        'class_': 'Adv.', 
        'group': 'Kin',
        'place': '2',
        'placeTo': '2',
        'id': 2,
        'finalist': None,
        'competitionGroup': 'Kin.',
        'competitionClass': 'Beg./Adv.'
    }
    assert competition.__dict__ == expected

def test_combineRowsByPerson():
    rows = [
        worker.ResultRow('Max', 'Mustermann', 'TSC Entenhausen', '2', 'Kin', 'Adv.', 'Cha Cha', '-', '-', 'Kin.', 'Adv.'),
        worker.ResultRow('Max', 'Mustermann', 'TSC Entenhausen', '2', 'Kin', 'Adv.', 'Rumba', '2', '2', 'Kin.', 'Adv.'),
        worker.ResultRow('Max', 'Mustermann', 'TSC Entenhausen', '2', 'Kin', 'Beg.', 'Jive', '1', '1', 'Kin.', 'Beg.'),
        worker.ResultRow('Maxime', 'Musterfrau', '1. SC Entenhausen', '1', 'Kin', 'Adv.', 'Rumba', '1', '1', 'Kin.', 'Adv.')
    ]
    dataWorker = worker.DataWorker()
    result = dataWorker.combineRowsByPerson(rows)
    expected = {
        worker.ResultPerson('Max', 'Mustermann', 'TSC Entenhausen'): [
            worker.CompetitionResult('Rumba', 'Kin', 'Adv.', '2', '2', '2', 'Kin.', 'Adv.'),
            worker.CompetitionResult('Jive', 'Kin', 'Beg.', '1', '1', '2', 'Kin.', 'Beg.')
        ],
        worker.ResultPerson('Maxime', 'Musterfrau', '1. SC Entenhausen'): [
            worker.CompetitionResult('Rumba', 'Kin', 'Adv.', '1', '1', '1', 'Kin.', 'Adv.')
        ]
    }
    assert result == expected

def test_checkUniqueIds_True():
    person1 = worker.ResultPerson('Max', 'Mustermann', 'TSC Entenhausen')
    person2 = worker.ResultPerson('Maxime', 'Musterfrau', '1. SC Entenhausen')
    data = {
        person1: [
            worker.CompetitionResult('Rumba', 'Kin', 'Adv.', '2', '2', 2, 'Kin.', 'Adv.'),
            worker.CompetitionResult('Jive', 'Kin', 'Beg.', '1', '1', 2, 'Kin.', 'Beg.')
        ],
        person2: [
            worker.CompetitionResult('Rumba', 'Kin', 'Adv.', '1', '1', 1, 'Kin.', 'Adv.')
        ]
    }
    dataWorker = worker.DataWorker()
    assert dataWorker.checkUniqueIds(data) == True
    assert person1.id == 2
    assert person2.id == 1

def test_checkUniqueIds_False():
    person1 = worker.ResultPerson('Max', 'Mustermann', 'TSC Entenhausen')
    person2 = worker.ResultPerson('Maxime', 'Musterfrau', '1. SC Entenhausen')
    data = {
        person1: [
            worker.CompetitionResult('Rumba', 'Kin', 'Adv.', '2', '2', 2, 'Kin.', 'Adv.'),
            worker.CompetitionResult('Jive', 'Kin', 'Beg.', '1', '1', 3, 'Kin.', 'Beg.')
        ],
        person2: [
            worker.CompetitionResult('Rumba', 'Kin', 'Adv.', '1', '1', 1, 'Kin.', 'Adv.')
        ]
    }
    dataWorker = worker.DataWorker()
    assert dataWorker.checkUniqueIds(data) == False
    assert person1.id == None
    assert person2.id == 1

@pytest.fixture(params=range(5))
def fixture_consolidateGroups(request):
    person1 = worker.ResultPerson('Max 1', 'Mustermann', 'TSC Entenhausen')
    person2 = worker.ResultPerson('Max 2', 'Mustermann', 'TSC Entenhausen')
    person3 = worker.ResultPerson('Max 3', 'Mustermann', 'TSC Entenhausen')
    person4 = worker.ResultPerson('Max 4', 'Mustermann', 'TSC Entenhausen')
    # persons = (person1, person2, person3, person4)

    dict1 = {
        person1: [
            worker.CompetitionResult('Rumba', 'Kin.', 'Adv.', '2', '2', 2, 'Kin.', 'Adv.'),
            worker.CompetitionResult('Jive', 'Kin.', 'Beg.', '1', '1', 3, 'Kin.', 'Beg.')
        ]
    }
    dict2 = {
        person2: [
            worker.CompetitionResult('Rumba', 'Kin.', 'Adv.', '2', '2', 2, 'Kin.', 'Adv.'),
            worker.CompetitionResult('Jive', 'Kin./Jun.', 'Beg.', '1', '1', 3, 'Kin./Jun.', 'Beg.')
        ]
    }
    dict3 = {
        person3: [
            worker.CompetitionResult('Rumba', 'Kin.', 'Adv.', '2', '2', 2, 'Kin.', 'Adv.')
        ]
    }
    dict4 = {
        person4: [
            worker.CompetitionResult('Rumba', 'Kin./Jun.', 'Adv.', '2', '2', 2, 'Kin./Jun.', 'Adv.')
        ]
    }
    dict5 = {
        person4: [
            worker.CompetitionResult('Rumba', 'Kin./Jun.', 'Adv.', '2', '2', 2, 'Kin./Jun.', 'Adv.'),
            worker.CompetitionResult('Cha Cha', 'Jun./Jug.', 'Beg.', '3', '4', 2, 'Jun./Jug.', 'Beg.')
        ]
    }

    cases = (
        (dict1|dict3, (True, False), {}),
        (dict1|dict2|dict3, (True, True), {}),
        (dict4, (False, False), {person4: 'Kin./Jun.'}),
        (dict1|dict2|dict3|dict4, (False, True), {person4: 'Kin./Jun.'}),
        (dict5, (True, True), {person4: 'Jun.'}),
    )
    return cases[request.param]

@pytest.fixture(params=range(2))
def fixture_consolidateGroups_fail(request, fixture_consolidateGroups):
    person = worker.ResultPerson('Max 5', 'Mustermann', 'TSC Entenhausen')

    dict1 = {
        person: [
            worker.CompetitionResult('Rumba', 'Kin.', 'Adv.', '2', '2', 2, 'Kin.', 'Adv.'),
            worker.CompetitionResult('Jive', 'Jun.', 'Beg.', '1', '1', 3, 'Jun.', 'Adv.')
        ]
    }

    dict2 = {
        person: [
            worker.CompetitionResult('Rumba', 'Kin.', 'Adv.', '2', '2', 2, 'Kin.', 'Adv.'),
            worker.CompetitionResult('Jive', 'Hgr', 'Beg.', '1', '1', 3, 'Hgr', 'Adv.')
        ]
    }

    cases = (
        dict1 | fixture_consolidateGroups[0],
        dict2 | fixture_consolidateGroups[0]
    )
    return cases[request.param]

def test_consolidateGroups(fixture_consolidateGroups):
    data = fixture_consolidateGroups[0]
    dataWorker = worker.DataWorker()

    assert dataWorker.consolidateGroups(data) == fixture_consolidateGroups[1]

    for person in data:
        assert person.group == fixture_consolidateGroups[2].get(person, 'Kin.')

def test_consolidateGroups_failing(fixture_consolidateGroups_fail):
    data = fixture_consolidateGroups_fail
    dataWorker = worker.DataWorker()

    with pytest.raises(Exception):
        dataWorker.consolidateGroups(data)