import xml.etree.ElementTree as ET

from Entities import Question, QuestionType, QuestionIndividual, Classification, \
    ClassificationIndividual, Response


class XMLReader:
    base_iri = r'http://www.semanticweb.org/bkorousicseljak/ontologies/2023/5/Comfocus_v1/COMFOCUS_'

    def __init__(self, ontology, file):
        self.ontology = ontology
        self.tree = ET.parse(file)

    def create_response_class(self):
        response_class = Response(label='response', id_=self.ontology.get_counter())
        self.ontology.update_counter()
        return response_class

    def read_questions(self):
        root = self.tree.getroot()

        single_choice_questions = []
        for subclass in root.findall('{http://www.w3.org/2002/07/owl#}SubClassOf'):
            if (len(subclass) == 2 and
                    subclass[0].tag == '{http://www.w3.org/2002/07/owl#}Class' and
                    subclass[1].tag == '{http://www.w3.org/2002/07/owl#}Class'):
                child = subclass[0]
                parent = subclass[1]
                if ('IRI' in parent.attrib.keys() and
                        parent.attrib['IRI'] == self.base_iri + '00000000000000000388'):
                    single_choice_questions.append(child.attrib['IRI'])

        single_choice_questions_dict = dict()
        for subclass in root.findall('{http://www.w3.org/2002/07/owl#}AnnotationAssertion'):
            if (len(subclass) == 3 and
                    subclass[0].tag == '{http://www.w3.org/2002/07/owl#}AnnotationProperty' and
                    'abbreviatedIRI' in subclass[0].attrib.keys() and
                    subclass[0].attrib['abbreviatedIRI'] == 'rdfs:label'):
                iri = subclass[1].text
                if iri in single_choice_questions and subclass[2].tag == '{http://www.w3.org/2002/07/owl#}Literal':
                    label = subclass[2].text.lower()
                    question = Question(
                        parent_iri=self.base_iri + '00000000000000000388',
                        iri=iri,
                        label=label,
                        question_type=QuestionType.SINGLE_CHOICE)
                    individual = QuestionIndividual(
                        parent_iri=iri,
                        id_=self.ontology.get_counter(),
                        label=label)
                    self.ontology.update_counter()
                    question.add_individual(individual)
                    single_choice_questions_dict[iri] = question

        multiple_choice_questions = []
        for subclass in root.findall('{http://www.w3.org/2002/07/owl#}SubClassOf'):
            if (len(subclass) == 2 and
                    subclass[0].tag == '{http://www.w3.org/2002/07/owl#}Class' and
                    subclass[1].tag == '{http://www.w3.org/2002/07/owl#}Class'):
                child = subclass[0]
                parent = subclass[1]
                if ('IRI' in parent.attrib.keys() and
                        parent.attrib['IRI'] == self.base_iri + '00000000000000000361'):
                    multiple_choice_questions.append(child.attrib['IRI'])

        multiple_choice_questions_dict = dict()
        for subclass in root.findall('{http://www.w3.org/2002/07/owl#}AnnotationAssertion'):
            if (len(subclass) == 3 and
                    subclass[0].tag == '{http://www.w3.org/2002/07/owl#}AnnotationProperty' and
                    'abbreviatedIRI' in subclass[0].attrib.keys() and
                    subclass[0].attrib['abbreviatedIRI'] == 'rdfs:label'):
                iri = subclass[1].text
                if iri in multiple_choice_questions and subclass[2].tag == '{http://www.w3.org/2002/07/owl#}Literal':
                    label = subclass[2].text.lower()
                    question = Question(
                        parent_iri=self.base_iri + '00000000000000000361',
                        iri=iri,
                        label=label,
                        question_type=QuestionType.MULTIPLE_CHOICE)
                    individual = QuestionIndividual(
                        parent_iri=iri,
                        id_=self.ontology.get_counter(),
                        label=label)
                    self.ontology.update_counter()
                    question.add_individual(individual)
                    multiple_choice_questions_dict[iri] = question

        bipolar_questions = []
        for subclass in root.findall('{http://www.w3.org/2002/07/owl#}SubClassOf'):
            if (len(subclass) == 2 and
                    subclass[0].tag == '{http://www.w3.org/2002/07/owl#}Class' and
                    subclass[1].tag == '{http://www.w3.org/2002/07/owl#}Class'):
                child = subclass[0]
                parent = subclass[1]
                if ('IRI' in parent.attrib.keys() and
                        parent.attrib['IRI'] == '#OWLClass_d10d7fb9_c539_4fd4_821c_e4057f468bd1'):
                    bipolar_questions.append(child.attrib['IRI'])

        bipolar_questions_dict = dict()
        for subclass in root.findall('{http://www.w3.org/2002/07/owl#}AnnotationAssertion'):
            if (len(subclass) == 3 and
                    subclass[0].tag == '{http://www.w3.org/2002/07/owl#}AnnotationProperty' and
                    'abbreviatedIRI' in subclass[0].attrib.keys() and
                    subclass[0].attrib['abbreviatedIRI'] == 'rdfs:label'):
                iri = subclass[1].text
                if iri in bipolar_questions and subclass[2].tag == '{http://www.w3.org/2002/07/owl#}Literal':
                    label = subclass[2].text.lower()
                    question = Question(
                        parent_iri='#OWLClass_d10d7fb9_c539_4fd4_821c_e4057f468bd1',
                        iri=iri,
                        label=label,
                        question_type=QuestionType.BIPOLAR)
                    individual = QuestionIndividual(
                        parent_iri=iri,
                        id_=self.ontology.get_counter(),
                        label=label)
                    self.ontology.update_counter()
                    question.add_individual(individual)
                    bipolar_questions_dict[iri] = question

        open_questions = []
        for subclass in root.findall('{http://www.w3.org/2002/07/owl#}SubClassOf'):
            if (len(subclass) == 2 and
                    subclass[0].tag == '{http://www.w3.org/2002/07/owl#}Class' and
                    subclass[1].tag == '{http://www.w3.org/2002/07/owl#}Class'):
                child = subclass[0]
                parent = subclass[1]
                if ('IRI' in parent.attrib.keys() and
                        parent.attrib['IRI'] == self.base_iri + '00000000000000000358'):
                    open_questions.append(child.attrib['IRI'])

        open_questions_dict = dict()
        for subclass in root.findall('{http://www.w3.org/2002/07/owl#}AnnotationAssertion'):
            if (len(subclass) == 3 and
                    subclass[0].tag == '{http://www.w3.org/2002/07/owl#}AnnotationProperty' and
                    'abbreviatedIRI' in subclass[0].attrib.keys() and
                    subclass[0].attrib['abbreviatedIRI'] == 'rdfs:label'):
                iri = subclass[1].text
                if iri in open_questions and subclass[2].tag == '{http://www.w3.org/2002/07/owl#}Literal':
                    label = subclass[2].text.lower()
                    question = Question(
                        parent_iri=self.base_iri + '00000000000000000358',
                        iri=iri,
                        label=label,
                        question_type=QuestionType.OPEN)
                    individual = QuestionIndividual(
                        parent_iri=iri,
                        id_=self.ontology.get_counter(),
                        label=label)
                    self.ontology.update_counter()
                    question.add_individual(individual)
                    open_questions_dict[iri] = question

        matrix_questions = []
        for subclass in root.findall('{http://www.w3.org/2002/07/owl#}SubClassOf'):
            if (len(subclass) == 2 and
                    subclass[0].tag == '{http://www.w3.org/2002/07/owl#}Class' and
                    subclass[1].tag == '{http://www.w3.org/2002/07/owl#}Class'):
                child = subclass[0]
                parent = subclass[1]
                if ('IRI' in parent.attrib.keys() and
                        parent.attrib['IRI'] == self.base_iri + '00000000000000000533'):
                    matrix_questions.append(child.attrib['IRI'])

        matrix_question_items = []
        for subclass in root.findall('{http://www.w3.org/2002/07/owl#}SubClassOf'):
            if (len(subclass) == 2 and
                    subclass[0].tag == '{http://www.w3.org/2002/07/owl#}Class' and
                    subclass[1].tag == '{http://www.w3.org/2002/07/owl#}Class'):
                child = subclass[0]
                parent = subclass[1]
                if ('IRI' in parent.attrib.keys() and
                        parent.attrib['IRI'] in matrix_questions):
                    matrix_question_items.append(child.attrib['IRI'])

        matrix_question_items_dict = dict()
        for subclass in root.findall('{http://www.w3.org/2002/07/owl#}AnnotationAssertion'):
            if (len(subclass) == 3 and
                    subclass[0].tag == '{http://www.w3.org/2002/07/owl#}AnnotationProperty' and
                    'abbreviatedIRI' in subclass[0].attrib.keys() and
                    subclass[0].attrib['abbreviatedIRI'] == 'rdfs:label'):
                iri = subclass[1].text
                if iri in matrix_question_items and subclass[2].tag == '{http://www.w3.org/2002/07/owl#}Literal':
                    label = subclass[2].text.lower()
                    question = Question(
                        parent_iri=self.base_iri + '00000000000000000533',
                        iri=iri,
                        label=label,
                        question_type=QuestionType.MATRIX)
                    individual = QuestionIndividual(
                        parent_iri=iri,
                        id_=self.ontology.get_counter(),
                        label=label)
                    self.ontology.update_counter()
                    question.add_individual(individual)
                    matrix_question_items_dict[iri] = question

        return [single_choice_questions_dict,
                multiple_choice_questions_dict,
                bipolar_questions_dict,
                open_questions_dict,
                matrix_question_items_dict]

    def read_questions_and_question_instances(self):
        root = self.tree.getroot()

        single_choice_questions = []
        for subclass in root.findall('{http://www.w3.org/2002/07/owl#}SubClassOf'):
            if (len(subclass) == 2 and
                    subclass[0].tag == '{http://www.w3.org/2002/07/owl#}Class' and
                    subclass[1].tag == '{http://www.w3.org/2002/07/owl#}Class'):
                child = subclass[0]
                parent = subclass[1]
                if ('IRI' in parent.attrib.keys() and
                        parent.attrib['IRI'] == self.base_iri + '00000000000000000388'):
                    single_choice_questions.append(child.attrib['IRI'])

        single_choice_questions_dict = dict()
        for subclass in root.findall('{http://www.w3.org/2002/07/owl#}AnnotationAssertion'):
            if (len(subclass) == 3 and
                    subclass[0].tag == '{http://www.w3.org/2002/07/owl#}AnnotationProperty' and
                    'abbreviatedIRI' in subclass[0].attrib.keys() and
                    subclass[0].attrib['abbreviatedIRI'] == 'rdfs:label'):
                iri = subclass[1].text
                if iri in single_choice_questions and subclass[2].tag == '{http://www.w3.org/2002/07/owl#}Literal':
                    label = subclass[2].text.lower()
                    question = Question(
                        parent_iri=self.base_iri + '00000000000000000388',
                        iri=iri,
                        label=label,
                        question_type=QuestionType.SINGLE_CHOICE)

                    individuals = []
                    for class_individual in root.findall('{http://www.w3.org/2002/07/owl#}ClassAssertion'):
                        if (len(class_individual) == 2 and
                                class_individual[0].tag == '{http://www.w3.org/2002/07/owl#}Class' and
                                class_individual[1].tag == '{http://www.w3.org/2002/07/owl#}NamedIndividual'):
                            parent = class_individual[0]
                            child = class_individual[1]
                            if ('IRI' in parent.attrib.keys() and
                                    parent.attrib['IRI'] == iri):
                                individuals.append(child.attrib['IRI'])

                    for individual_assertion in root.findall('{http://www.w3.org/2002/07/owl#}AnnotationAssertion'):
                        if (len(individual_assertion) == 3 and
                                individual_assertion[0].tag == '{http://www.w3.org/2002/07/owl#}AnnotationProperty' and
                                'abbreviatedIRI' in individual_assertion[0].attrib.keys() and
                                individual_assertion[0].attrib['abbreviatedIRI'] == 'rdfs:label'):
                            individual_iri = individual_assertion[1].text
                            if (individual_iri in individuals and
                                    individual_assertion[2].tag == '{http://www.w3.org/2002/07/owl#}Literal'):
                                individual_label = individual_assertion[2].text.lower()

                                individual = ClassificationIndividual(
                                    parent_iri=iri,
                                    iri=individual_iri,
                                    label=individual_label)
                                question.add_individual(individual)

                    single_choice_questions_dict[iri] = question

        multiple_choice_questions = []
        for subclass in root.findall('{http://www.w3.org/2002/07/owl#}SubClassOf'):
            if (len(subclass) == 2 and
                    subclass[0].tag == '{http://www.w3.org/2002/07/owl#}Class' and
                    subclass[1].tag == '{http://www.w3.org/2002/07/owl#}Class'):
                child = subclass[0]
                parent = subclass[1]
                if ('IRI' in parent.attrib.keys() and
                        parent.attrib['IRI'] == self.base_iri + '00000000000000000361'):
                    multiple_choice_questions.append(child.attrib['IRI'])

        multiple_choice_questions_dict = dict()
        for subclass in root.findall('{http://www.w3.org/2002/07/owl#}AnnotationAssertion'):
            if (len(subclass) == 3 and
                    subclass[0].tag == '{http://www.w3.org/2002/07/owl#}AnnotationProperty' and
                    'abbreviatedIRI' in subclass[0].attrib.keys() and
                    subclass[0].attrib['abbreviatedIRI'] == 'rdfs:label'):
                iri = subclass[1].text
                if iri in multiple_choice_questions and subclass[2].tag == '{http://www.w3.org/2002/07/owl#}Literal':
                    label = subclass[2].text.lower()
                    question = Question(
                        parent_iri=self.base_iri + '00000000000000000361',
                        iri=iri,
                        label=label,
                        question_type=QuestionType.MULTIPLE_CHOICE)

                    individuals = []
                    for class_individual in root.findall('{http://www.w3.org/2002/07/owl#}ClassAssertion'):
                        if (len(class_individual) == 2 and
                                class_individual[0].tag == '{http://www.w3.org/2002/07/owl#}Class' and
                                class_individual[1].tag == '{http://www.w3.org/2002/07/owl#}NamedIndividual'):
                            parent = class_individual[0]
                            child = class_individual[1]
                            if ('IRI' in parent.attrib.keys() and
                                    parent.attrib['IRI'] == iri):
                                individuals.append(child.attrib['IRI'])

                    for individual_assertion in root.findall('{http://www.w3.org/2002/07/owl#}AnnotationAssertion'):
                        if (len(individual_assertion) == 3 and
                                individual_assertion[0].tag == '{http://www.w3.org/2002/07/owl#}AnnotationProperty' and
                                'abbreviatedIRI' in individual_assertion[0].attrib.keys() and
                                individual_assertion[0].attrib['abbreviatedIRI'] == 'rdfs:label'):
                            individual_iri = individual_assertion[1].text
                            if (individual_iri in individuals and
                                    individual_assertion[2].tag == '{http://www.w3.org/2002/07/owl#}Literal'):
                                individual_label = individual_assertion[2].text.lower()

                                individual = ClassificationIndividual(
                                    parent_iri=iri,
                                    iri=individual_iri,
                                    label=individual_label)
                                question.add_individual(individual)

                    multiple_choice_questions_dict[iri] = question

        bipolar_questions = []
        for subclass in root.findall('{http://www.w3.org/2002/07/owl#}SubClassOf'):
            if (len(subclass) == 2 and
                    subclass[0].tag == '{http://www.w3.org/2002/07/owl#}Class' and
                    subclass[1].tag == '{http://www.w3.org/2002/07/owl#}Class'):
                child = subclass[0]
                parent = subclass[1]
                if ('IRI' in parent.attrib.keys() and
                        parent.attrib['IRI'] == '#OWLClass_d10d7fb9_c539_4fd4_821c_e4057f468bd1'):
                    bipolar_questions.append(child.attrib['IRI'])

        bipolar_questions_dict = dict()
        for subclass in root.findall('{http://www.w3.org/2002/07/owl#}AnnotationAssertion'):
            if (len(subclass) == 3 and
                    subclass[0].tag == '{http://www.w3.org/2002/07/owl#}AnnotationProperty' and
                    'abbreviatedIRI' in subclass[0].attrib.keys() and
                    subclass[0].attrib['abbreviatedIRI'] == 'rdfs:label'):
                iri = subclass[1].text
                if iri in bipolar_questions and subclass[2].tag == '{http://www.w3.org/2002/07/owl#}Literal':
                    label = subclass[2].text.lower()
                    question = Question(
                        parent_iri='#OWLClass_d10d7fb9_c539_4fd4_821c_e4057f468bd1',
                        iri=iri,
                        label=label,
                        question_type=QuestionType.BIPOLAR)

                    individuals = []
                    for class_individual in root.findall('{http://www.w3.org/2002/07/owl#}ClassAssertion'):
                        if (len(class_individual) == 2 and
                                class_individual[0].tag == '{http://www.w3.org/2002/07/owl#}Class' and
                                class_individual[1].tag == '{http://www.w3.org/2002/07/owl#}NamedIndividual'):
                            parent = class_individual[0]
                            child = class_individual[1]
                            if ('IRI' in parent.attrib.keys() and
                                    parent.attrib['IRI'] == iri):
                                individuals.append(child.attrib['IRI'])

                    for individual_assertion in root.findall('{http://www.w3.org/2002/07/owl#}AnnotationAssertion'):
                        if (len(individual_assertion) == 3 and
                                individual_assertion[0].tag == '{http://www.w3.org/2002/07/owl#}AnnotationProperty' and
                                'abbreviatedIRI' in individual_assertion[0].attrib.keys() and
                                individual_assertion[0].attrib['abbreviatedIRI'] == 'rdfs:label'):
                            individual_iri = individual_assertion[1].text
                            if (individual_iri in individuals and
                                    individual_assertion[2].tag == '{http://www.w3.org/2002/07/owl#}Literal'):
                                individual_label = individual_assertion[2].text.lower()

                                individual = ClassificationIndividual(
                                    parent_iri=iri,
                                    iri=individual_iri,
                                    label=individual_label)
                                question.add_individual(individual)

                    bipolar_questions_dict[iri] = question

        open_questions = []
        for subclass in root.findall('{http://www.w3.org/2002/07/owl#}SubClassOf'):
            if (len(subclass) == 2 and
                    subclass[0].tag == '{http://www.w3.org/2002/07/owl#}Class' and
                    subclass[1].tag == '{http://www.w3.org/2002/07/owl#}Class'):
                child = subclass[0]
                parent = subclass[1]
                if ('IRI' in parent.attrib.keys() and
                        parent.attrib['IRI'] == self.base_iri + '00000000000000000358'):
                    open_questions.append(child.attrib['IRI'])

        open_questions_dict = dict()
        for subclass in root.findall('{http://www.w3.org/2002/07/owl#}AnnotationAssertion'):
            if (len(subclass) == 3 and
                    subclass[0].tag == '{http://www.w3.org/2002/07/owl#}AnnotationProperty' and
                    'abbreviatedIRI' in subclass[0].attrib.keys() and
                    subclass[0].attrib['abbreviatedIRI'] == 'rdfs:label'):
                iri = subclass[1].text
                if iri in open_questions and subclass[2].tag == '{http://www.w3.org/2002/07/owl#}Literal':
                    label = subclass[2].text.lower()
                    question = Question(
                        parent_iri=self.base_iri + '00000000000000000358',
                        iri=iri,
                        label=label,
                        question_type=QuestionType.OPEN)

                    individuals = []
                    for class_individual in root.findall('{http://www.w3.org/2002/07/owl#}ClassAssertion'):
                        if (len(class_individual) == 2 and
                                class_individual[0].tag == '{http://www.w3.org/2002/07/owl#}Class' and
                                class_individual[1].tag == '{http://www.w3.org/2002/07/owl#}NamedIndividual'):
                            parent = class_individual[0]
                            child = class_individual[1]
                            if ('IRI' in parent.attrib.keys() and
                                    parent.attrib['IRI'] == iri):
                                individuals.append(child.attrib['IRI'])

                    for individual_assertion in root.findall('{http://www.w3.org/2002/07/owl#}AnnotationAssertion'):
                        if (len(individual_assertion) == 3 and
                                individual_assertion[0].tag == '{http://www.w3.org/2002/07/owl#}AnnotationProperty' and
                                'abbreviatedIRI' in individual_assertion[0].attrib.keys() and
                                individual_assertion[0].attrib['abbreviatedIRI'] == 'rdfs:label'):
                            individual_iri = individual_assertion[1].text
                            if (individual_iri in individuals and
                                    individual_assertion[2].tag == '{http://www.w3.org/2002/07/owl#}Literal'):
                                individual_label = individual_assertion[2].text.lower()

                                individual = ClassificationIndividual(
                                    parent_iri=iri,
                                    iri=individual_iri,
                                    label=individual_label)
                                question.add_individual(individual)

                    open_questions_dict[iri] = question

        matrix_questions = []
        for subclass in root.findall('{http://www.w3.org/2002/07/owl#}SubClassOf'):
            if (len(subclass) == 2 and
                    subclass[0].tag == '{http://www.w3.org/2002/07/owl#}Class' and
                    subclass[1].tag == '{http://www.w3.org/2002/07/owl#}Class'):
                child = subclass[0]
                parent = subclass[1]
                if ('IRI' in parent.attrib.keys() and
                        parent.attrib['IRI'] == self.base_iri + '00000000000000000533'):
                    matrix_questions.append(child.attrib['IRI'])

        matrix_question_items = []
        for subclass in root.findall('{http://www.w3.org/2002/07/owl#}SubClassOf'):
            if (len(subclass) == 2 and
                    subclass[0].tag == '{http://www.w3.org/2002/07/owl#}Class' and
                    subclass[1].tag == '{http://www.w3.org/2002/07/owl#}Class'):
                child = subclass[0]
                parent = subclass[1]
                if ('IRI' in parent.attrib.keys() and
                        parent.attrib['IRI'] in matrix_questions):
                    matrix_question_items.append(child.attrib['IRI'])

        matrix_question_items_dict = dict()
        for subclass in root.findall('{http://www.w3.org/2002/07/owl#}AnnotationAssertion'):
            if (len(subclass) == 3 and
                    subclass[0].tag == '{http://www.w3.org/2002/07/owl#}AnnotationProperty' and
                    'abbreviatedIRI' in subclass[0].attrib.keys() and
                    subclass[0].attrib['abbreviatedIRI'] == 'rdfs:label'):
                iri = subclass[1].text
                if iri in matrix_question_items and subclass[2].tag == '{http://www.w3.org/2002/07/owl#}Literal':
                    label = subclass[2].text.lower()
                    question = Question(
                        parent_iri=self.base_iri + '00000000000000000533',
                        iri=iri,
                        label=label,
                        question_type=QuestionType.MATRIX)

                    individuals = []
                    for class_individual in root.findall('{http://www.w3.org/2002/07/owl#}ClassAssertion'):
                        if (len(class_individual) == 2 and
                                class_individual[0].tag == '{http://www.w3.org/2002/07/owl#}Class' and
                                class_individual[1].tag == '{http://www.w3.org/2002/07/owl#}NamedIndividual'):
                            parent = class_individual[0]
                            child = class_individual[1]
                            if ('IRI' in parent.attrib.keys() and
                                    parent.attrib['IRI'] == iri):
                                individuals.append(child.attrib['IRI'])

                    for individual_assertion in root.findall('{http://www.w3.org/2002/07/owl#}AnnotationAssertion'):
                        if (len(individual_assertion) == 3 and
                                individual_assertion[0].tag == '{http://www.w3.org/2002/07/owl#}AnnotationProperty' and
                                'abbreviatedIRI' in individual_assertion[0].attrib.keys() and
                                individual_assertion[0].attrib['abbreviatedIRI'] == 'rdfs:label'):
                            individual_iri = individual_assertion[1].text
                            if (individual_iri in individuals and
                                    individual_assertion[2].tag == '{http://www.w3.org/2002/07/owl#}Literal'):
                                individual_label = individual_assertion[2].text.lower()

                                individual = ClassificationIndividual(
                                    parent_iri=iri,
                                    iri=individual_iri,
                                    label=individual_label)
                                question.add_individual(individual)

                    matrix_question_items_dict[iri] = question

        return [single_choice_questions_dict,
                multiple_choice_questions_dict,
                bipolar_questions_dict,
                open_questions_dict,
                matrix_question_items_dict]

    def read_classifications_and_classification_instances(self):
        root = self.tree.getroot()

        classifications = []
        for subclass in root.findall('{http://www.w3.org/2002/07/owl#}SubClassOf'):
            if (len(subclass) == 2 and
                    subclass[0].tag == '{http://www.w3.org/2002/07/owl#}Class' and
                    subclass[1].tag == '{http://www.w3.org/2002/07/owl#}Class'):
                child = subclass[0]
                parent = subclass[1]
                if ('IRI' in parent.attrib.keys() and
                        parent.attrib['IRI'] in ['#COMFOCUS_00000000000000000002',
                                                 'http://www.semanticweb.org/bkorousicseljak/ontologies/2023/5/'
                                                 'Comfocus_Contextv4#COMFOCUS_00000000000000000002']):
                    classifications.append(child.attrib['IRI'])

        classifications_dict = dict()
        for subclass in root.findall('{http://www.w3.org/2002/07/owl#}AnnotationAssertion'):
            if (len(subclass) == 3 and
                    subclass[0].tag == '{http://www.w3.org/2002/07/owl#}AnnotationProperty' and
                    'abbreviatedIRI' in subclass[0].attrib.keys() and
                    subclass[0].attrib['abbreviatedIRI'] == 'rdfs:label'):
                iri = subclass[1].text
                if iri in classifications and subclass[2].tag == '{http://www.w3.org/2002/07/owl#}Literal':
                    label = subclass[2].text.lower()
                    classification = Classification(
                        parent_iri='#COMFOCUS_00000000000000000002',
                        iri=iri,
                        label=label)

                    individuals = []
                    for class_individual in root.findall('{http://www.w3.org/2002/07/owl#}ClassAssertion'):
                        if (len(class_individual) == 2 and
                                class_individual[0].tag == '{http://www.w3.org/2002/07/owl#}Class' and
                                class_individual[1].tag == '{http://www.w3.org/2002/07/owl#}NamedIndividual'):
                            parent = class_individual[0]
                            child = class_individual[1]
                            if ('IRI' in parent.attrib.keys() and
                                    parent.attrib['IRI'] == iri):
                                individuals.append(child.attrib['IRI'])

                    for individual_assertion in root.findall('{http://www.w3.org/2002/07/owl#}AnnotationAssertion'):
                        if (len(individual_assertion) == 3 and
                                individual_assertion[0].tag == '{http://www.w3.org/2002/07/owl#}AnnotationProperty' and
                                'abbreviatedIRI' in individual_assertion[0].attrib.keys() and
                                individual_assertion[0].attrib['abbreviatedIRI'] == 'rdfs:label'):
                            individual_iri = individual_assertion[1].text
                            if (individual_iri in individuals and
                                    individual_assertion[2].tag == '{http://www.w3.org/2002/07/owl#}Literal'):
                                individual_label = individual_assertion[2].text.lower()

                                individual = ClassificationIndividual(
                                    parent_iri=iri,
                                    iri=individual_iri,
                                    label=individual_label)
                                classification.add_individual(individual)

                    classifications_dict[label] = classification

        return [classifications_dict]
