import copy
import dataclasses
import logging
from collections import defaultdict
from itertools import combinations
from typing import Any, Dict, List, Optional, Set, Tuple

import datasets
from pytorch_ie.annotations import BinaryRelation, Label, LabeledSpan, Span
from pytorch_ie.core import Annotation, AnnotationList, annotation_field
from pytorch_ie.documents import (
    TextBasedDocument,
    TextDocumentWithLabeledSpansAndBinaryRelations,
)

from pie_datasets import GeneratorBasedBuilder

log = logging.getLogger(__name__)


def dl2ld(dict_of_lists):
    return [dict(zip(dict_of_lists, t)) for t in zip(*dict_of_lists.values())]


def ld2dl(list_of_dicts, keys: Optional[List[str]] = None):
    return {k: [d[k] for d in list_of_dicts] for k in keys}


@dataclasses.dataclass(frozen=True)
class LabeledAnnotationCollection(Annotation):
    annotations: Tuple[Annotation, ...]
    label: str


@dataclasses.dataclass(frozen=True)
class MultiRelation(Annotation):
    heads: Tuple[Annotation, ...]  # sources == heads
    tails: Tuple[Annotation, ...]  # targets == tails
    label: str


@dataclasses.dataclass
class ArgMicroDocument(TextBasedDocument):
    topic_id: Optional[str] = None
    stance: AnnotationList[Label] = annotation_field()
    edus: AnnotationList[Span] = annotation_field(target="text")
    adus: AnnotationList[LabeledAnnotationCollection] = annotation_field(target="edus")
    relations: AnnotationList[MultiRelation] = annotation_field(target="adus")


def example_to_document(
    example: Dict[str, Any],
    adu_type_label: datasets.ClassLabel,
    edge_type_label: datasets.ClassLabel,
    stance_label: datasets.ClassLabel,
) -> ArgMicroDocument:
    stance = stance_label.int2str(example["stance"])
    document = ArgMicroDocument(
        id=example["id"],
        text=example["text"],
        topic_id=example["topic_id"] if example["topic_id"] != "UNDEFINED" else None,
    )
    if stance != "UNDEFINED":
        document.stance.append(Label(label=stance))

    # build EDUs
    edus_dict = {
        edu["id"]: Span(start=edu["start"], end=edu["end"]) for edu in dl2ld(example["edus"])
    }
    # build ADUs
    adu_id2edus = defaultdict(list)
    edges_multi_source = defaultdict(dict)
    for edge in dl2ld(example["edges"]):
        edge_type = edge_type_label.int2str(edge["type"])
        if edge_type == "seg":
            adu_id2edus[edge["trg"]].append(edus_dict[edge["src"]])
        elif edge_type == "add":
            if "src" not in edges_multi_source[edge["trg"]]:
                edges_multi_source[edge["trg"]]["src"] = []
            edges_multi_source[edge["trg"]]["src"].append(edge["src"])
        else:
            edges_multi_source[edge["id"]]["type"] = edge_type
            edges_multi_source[edge["id"]]["trg"] = edge["trg"]
            if "src" not in edges_multi_source[edge["id"]]:
                edges_multi_source[edge["id"]]["src"] = []
            edges_multi_source[edge["id"]]["src"].append(edge["src"])
    adus_dict = {}
    for adu in dl2ld(example["adus"]):
        adu_type = adu_type_label.int2str(adu["type"])
        adu_edus = adu_id2edus[adu["id"]]
        adus_dict[adu["id"]] = LabeledAnnotationCollection(
            annotations=tuple(adu_edus), label=adu_type
        )
    # build relations
    rels_dict = {}
    for edge_id, edge in edges_multi_source.items():
        edge_target = edge["trg"]
        if edge_target in edges_multi_source:
            targets = edges_multi_source[edge_target]["src"]
        else:
            targets = [edge_target]
        if any(target in edges_multi_source for target in targets):
            raise Exception("Multi-hop relations are not supported")
        rel = MultiRelation(
            heads=tuple(adus_dict[source] for source in edge["src"]),
            tails=tuple(adus_dict[target] for target in targets),
            label=edge["type"],
        )
        rels_dict[edge_id] = rel

    document.edus.extend(edus_dict.values())
    document.adus.extend(adus_dict.values())
    document.relations.extend(rels_dict.values())
    document.metadata["edu_ids"] = list(edus_dict.keys())
    document.metadata["adu_ids"] = list(adus_dict.keys())
    document.metadata["rel_ids"] = list(rels_dict.keys())

    document.metadata["rel_seg_ids"] = {
        edge["src"]: edge["id"]
        for edge in dl2ld(example["edges"])
        if edge_type_label.int2str(edge["type"]) == "seg"
    }
    document.metadata["rel_add_ids"] = {
        edge["src"]: edge["id"]
        for edge in dl2ld(example["edges"])
        if edge_type_label.int2str(edge["type"]) == "add"
    }
    return document


def document_to_example(
    document: ArgMicroDocument,
    adu_type_label: datasets.ClassLabel,
    edge_type_label: datasets.ClassLabel,
    stance_label: datasets.ClassLabel,
) -> Dict[str, Any]:
    stance = document.stance[0].label if len(document.stance) else "UNDEFINED"
    result = {
        "id": document.id,
        "text": document.text,
        "topic_id": document.topic_id or "UNDEFINED",
        "stance": stance_label.str2int(stance),
    }

    # construct EDUs
    edus = {
        edu: {"id": edu_id, "start": edu.start, "end": edu.end}
        for edu_id, edu in zip(document.metadata["edu_ids"], document.edus)
    }
    result["edus"] = ld2dl(
        sorted(edus.values(), key=lambda x: x["id"]), keys=["id", "start", "end"]
    )

    # construct ADUs
    adus = {
        adu: {"id": adu_id, "type": adu_type_label.str2int(adu.label)}
        for adu_id, adu in zip(document.metadata["adu_ids"], document.adus)
    }
    result["adus"] = ld2dl(sorted(adus.values(), key=lambda x: x["id"]), keys=["id", "type"])

    # construct edges
    rels_dict: Dict[str, MultiRelation] = {
        rel_id: rel for rel_id, rel in zip(document.metadata["rel_ids"], document.relations)
    }
    heads2rel_id = {
        rel.heads: red_id for red_id, rel in zip(document.metadata["rel_ids"], document.relations)
    }
    edges = []
    for rel_id, rel in rels_dict.items():
        # if it is an undercut attack, we need to change the target to the relation that connects the target
        if rel.label == "und":
            target_id = heads2rel_id[rel.tails]
        else:
            if len(rel.tails) > 1:
                raise Exception("Multi-target relations are not supported")
            target_id = adus[rel.tails[0]]["id"]
        source_id = adus[rel.heads[0]]["id"]
        edge = {
            "id": rel_id,
            "src": source_id,
            "trg": target_id,
            "type": edge_type_label.str2int(rel.label),
        }
        edges.append(edge)
        # if it is an additional support, we need to change the source to the relation that connects the source
        for head in rel.heads[1:]:
            source_id = adus[head]["id"]
            edge_id = document.metadata["rel_add_ids"][source_id]
            edge = {
                "id": edge_id,
                "src": source_id,
                "trg": rel_id,
                "type": edge_type_label.str2int("add"),
            }
            edges.append(edge)

    for adu_id, adu in zip(document.metadata["adu_ids"], document.adus):
        for edu in adu.annotations:
            source_id = edus[edu]["id"]
            target_id = adus[adu]["id"]
            edge_id = document.metadata["rel_seg_ids"][source_id]
            edge = {
                "id": edge_id,
                "src": source_id,
                "trg": target_id,
                "type": edge_type_label.str2int("seg"),
            }
            edges.append(edge)

    result["edges"] = ld2dl(
        sorted(edges, key=lambda x: x["id"]), keys=["id", "src", "trg", "type"]
    )
    return result


def convert_to_text_document_with_labeled_spans_and_binary_relations(
    doc: ArgMicroDocument,
) -> TextDocumentWithLabeledSpansAndBinaryRelations:
    # convert adus to entities
    entities = []
    adu2entity: Dict[LabeledAnnotationCollection, Span] = {}
    for adu in doc.adus:
        edus: Set[Span] = set(adu.annotations)
        start = min(edu.start for edu in edus)
        end = max(edu.end for edu in edus)
        # assert there are no edus overlapping with the adu, but not part of it
        for edu in doc.edus:
            if (start <= edu.start < end or start < edu.end <= end) and edu not in edus:
                raise Exception(f"edu {edu} is overlapping with adu {adu}, but is not part of it")
        entity = LabeledSpan(start=start, end=end, label=adu.label)
        entities.append(entity)
        adu2entity[adu] = entity
    relations = []
    for relation in doc.relations:
        # add all possible combinations of heads and tails
        for head in relation.heads:
            for tail in relation.tails:
                rel = BinaryRelation(
                    label=relation.label, head=adu2entity[head], tail=adu2entity[tail]
                )
                relations.append(rel)
        # also add the relations between the heads themselves
        for head1, head2 in combinations(relation.heads, 2):
            rel = BinaryRelation(label="joint", head=adu2entity[head1], tail=adu2entity[head2])
            relations.append(rel)
            # also add the reverse relation
            rel = BinaryRelation(label="joint", head=adu2entity[head2], tail=adu2entity[head1])
            relations.append(rel)

    metadata = copy.deepcopy(doc.metadata)
    if len(doc.stance) > 0:
        metadata["stance"] = doc.stance[0].label
    metadata["topic"] = doc.topic_id
    result = TextDocumentWithLabeledSpansAndBinaryRelations(
        text=doc.text, id=doc.id, metadata=doc.metadata
    )
    result.labeled_spans.extend(entities)
    result.binary_relations.extend(relations)

    return result


class ArgMicro(GeneratorBasedBuilder):
    DOCUMENT_TYPE = ArgMicroDocument

    DOCUMENT_CONVERTERS = {
        TextDocumentWithLabeledSpansAndBinaryRelations: convert_to_text_document_with_labeled_spans_and_binary_relations
    }

    BASE_DATASET_PATH = "DFKI-SLT/argmicro"
    BASE_DATASET_REVISION = "282733d6d57243f2a202d81143c4e31bb250e663"

    BUILDER_CONFIGS = [datasets.BuilderConfig(name="en"), datasets.BuilderConfig(name="de")]

    def _generate_document_kwargs(self, dataset):
        return {
            "adu_type_label": dataset.features["adus"].feature["type"],
            "edge_type_label": dataset.features["edges"].feature["type"],
            "stance_label": dataset.features["stance"],
        }

    def _generate_document(self, example, **kwargs):
        return example_to_document(example, **kwargs)