import logging

class ResultRow:
    def __init__(self, firstName, lastName, club, id, group, class_, dance, place, placeTo):
        self.firstName = firstName
        self.lastName = lastName
        self.name = f'{firstName} {lastName}'
        self.club = club
        self.id = id
        self.group = group
        self.class_ = class_
        self.dance = dance
        self.place = place
        self.placeTo = placeTo

class ResultPerson:
    def __init__(self, firstName, lastName, club, id = None, group = None):
        self.firstName = firstName
        self.lastName = lastName
        self.name = f'{firstName} {lastName}'
        self.club = club
        self.id = id
        self.group = group
    
    @staticmethod
    def extractFromResultRow(row: ResultRow):
        return ResultPerson(
            firstName=row.firstName,
            lastName=row.lastName,
            club=row.club
        )
    
    def __eq__(self, o):
        if not isinstance(o, ResultPerson):
            return False
        
        return (
            self.firstName == o.firstName and
            self.lastName == o.lastName and
            self.club == o.club and
            self.id == o.id
        )
    
    def __repr__(self):
        if self.id is None:
            return f'{self.name} ({self.club})'
        else:
            return f'{self.name} ({self.club}) [{self.id}]'
        
    def __hash__(self):
        text = str(self)
        return text.__hash__()

class CompetitionResult:
    def __init__(self, dance, group, class_, place, placeTo, id):
        self.dance = dance
        self.group = group
        self.class_ = class_
        self.place = place
        self.placeTo = placeTo
        self.id = int(id)
    
    @staticmethod
    def extractFromResultRow(row: ResultRow):
        return CompetitionResult(
            dance=row.dance,
            group=row.group,
            class_=row.class_,
            place=row.place, placeTo=row.placeTo,
            id=row.id
        )
    
    def __repr__(self):
        if self.place == self.placeTo:
            result = f'{self.place}.'
        else:
            result = f'{self.place}.-{self.placeTo}.'
        return f'Result[{self.id}]({self.group} {self.class_} {self.dance} as {result})'

    def __eq__(self, o):
        if not isinstance(o, CompetitionResult):
            return False
        
        return (
            self.dance == o.dance and
            self.class_ == o.class_ and
            self.group == o.group and
            self.place == o.place and self.placeTo == o.placeTo and
            self.id == o.id
        )

class CSVExtractor:
    def __init__(self):
        self.l = logging.getLogger('solo_turnier.worker')

    def mapCSVImport(self, imported) -> list[ResultRow]:
        ret = []

        def __processRow(row):
            result = ResultRow(
                dance=row[4],
                id=row[5],
                firstName=row[6], lastName=row[7],
                club=row[10],
                place=row[12], placeTo=row[13],
                group=row[15], class_=row[16]
            )
            ret.append(result)

        for row in imported['data']:
            __processRow(row)
        
        return ret

class DataWorker:
    def __init__(self):
        self.l = logging.getLogger('solo_turnier.worker')
    
    def combineRowsByPerson(self, rows: list[ResultRow]) -> dict[ResultPerson, list[CompetitionResult]]:
        ret = {}
        for row in rows:
            result = CompetitionResult.extractFromResultRow(row)

            if result.place == '-' or result.placeTo == '-':
                continue
            
            person = ResultPerson.extractFromResultRow(row)
            if person not in ret:
                ret[person] = []
            ret[person].append(result)
        return ret

    def checkUniqueIds(self, data: dict[ResultPerson, list[CompetitionResult]]) -> bool:
        unique = True
        for person in data:
            ids = set([c.id for c in data[person]])
            if len(ids) == 1:
                person.id = list(ids)[0]
            else:
                unique = False

        return unique