# coding=utf-8
# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Fairlex: A multilingual benchmark for evaluating fairness in legal text processing."""

import json
import os
import textwrap

import datasets


MAIN_CITATION = """\
@inproceedings{chalkidis-etal-2022-fairlex,
    author={Chalkidis, Ilias and Passini, Tommaso and Zhang, Sheng and
            Tomada, Letizia and Schwemer, Sebastian Felix and Søgaard, Anders},
    title={FairLex: A Multilingual Benchmark for Evaluating Fairness in Legal Text Processing},
    booktitle={Proceedings of the 60th Annual Meeting of the Association for Computational Linguistics},
    year={2022},
    address={Dublin, Ireland}
}
"""

_DESCRIPTION = """\
Fairlex: A multilingual benchmark for evaluating fairness in legal text processing.
"""

ECTHR_ARTICLES = ["2", "3", "5", "6", "8", "9", "10", "11", "14", "P1-1"]

SCDB_ISSUE_AREAS = [
    "Criminal Procedure",
    "Civil Rights",
    "First Amendment",
    "Due Process",
    "Privacy",
    "Attorneys",
    "Unions",
    "Economic Activity",
    "Judicial Power",
    "Federalism",
    "Federal Taxation",
]

FSCS_LABELS = ["dismissal", "approval"]

CAIL_LABELS = ["0", "<=12", "<=36", "<=60", "<=120", ">120"]


class FairlexConfig(datasets.BuilderConfig):
    """BuilderConfig for Fairlex."""

    def __init__(
        self,
        label_column,
        url,
        data_url,
        citation,
        label_classes=None,
        multi_label=None,
        attributes=None,
        **kwargs,
    ):
        """BuilderConfig for Fairlex.

        Args:
          label_column: `string`, name of the column in the jsonl file corresponding
            to the label
          url: `string`, url for the original project
          data_url: `string`, url to download the zip file from
          data_file: `string`, filename for data set
          citation: `string`, citation for the data set
          url: `string`, url for information about the data set
          label_classes: `list[string]`, the list of classes if the label is
            categorical. If not provided, then the label will be of type
            `datasets.Value('float32')`.
          multi_label: `boolean`, True if the task is multi-label
          attributes: `List<string>`, names of the protected attributes
          **kwargs: keyword arguments forwarded to super.
        """
        super(FairlexConfig, self).__init__(version=datasets.Version("1.0.0", ""), **kwargs)
        self.label_column = label_column
        self.label_classes = label_classes
        self.multi_label = multi_label
        self.attributes = attributes
        self.url = url
        self.data_url = data_url
        self.citation = citation


class Fairlex(datasets.GeneratorBasedBuilder):
    """Fairlex: A multilingual benchmark for evaluating fairness in legal text processing. Version 1.0"""

    BUILDER_CONFIGS = [
        FairlexConfig(
            name="ecthr",
            description=textwrap.dedent(
                """\
            The European Court of Human Rights (ECtHR) hears allegations that a state has breached human rights
            provisions of the European Convention of Human Rights (ECHR). We use the dataset of Chalkidis et al.
            (2021), which contains 11K cases from ECtHR's public database. Each case is mapped to articles of the ECHR
            that were violated (if any). This is a multi-label text classification task. Given the facts of a case,
            the goal is to predict the ECHR articles that were violated, if any, as decided (ruled) by the court."""
            ),
            label_column="labels",
            label_classes=ECTHR_ARTICLES,
            multi_label=True,
            attributes=[
                ("applicant_age", ["n/a", "<=35", "<=65", ">65"]),
                ("applicant_gender", ["n/a", "male", "female"]),
                ("defendant_state", ["C.E. European", "Rest of Europe"]),
            ],
            data_url="https://zenodo.org/record/6322643/files/ecthr.zip",
            url="https://huggingface.co/datasets/ecthr_cases",
            citation=textwrap.dedent(
                """\
            @inproceedings{chalkidis-etal-2021-paragraph,
                title = "Paragraph-level Rationale Extraction through Regularization: A case study on {E}uropean Court of Human Rights Cases",
                author = "Chalkidis, Ilias  and
                  Fergadiotis, Manos  and
                  Tsarapatsanis, Dimitrios  and
                  Aletras, Nikolaos  and
                  Androutsopoulos, Ion  and
                  Malakasiotis, Prodromos",
                booktitle = "Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies",
                month = jun,
                year = "2021",
                address = "Online",
                publisher = "Association for Computational Linguistics",
                url = "https://aclanthology.org/2021.naacl-main.22",
                doi = "10.18653/v1/2021.naacl-main.22",
                pages = "226--241",
            }
            }"""
            ),
        ),
        FairlexConfig(
            name="scotus",
            description=textwrap.dedent(
                """\
            The US Supreme Court (SCOTUS) is the highest federal court in the United States of America and generally
            hears only the most controversial or otherwise complex cases which have not been sufficiently well solved
            by lower courts. We combine information from SCOTUS opinions with the Supreme Court DataBase (SCDB)
            (Spaeth, 2020). SCDB provides metadata (e.g., date of publication, decisions, issues, decision directions
            and many more) for all cases. We consider the available 14 thematic issue areas (e.g, Criminal Procedure,
            Civil Rights, Economic Activity, etc.). This is a single-label multi-class document classification task.
            Given the court opinion, the goal is to predict the issue area whose focus is on the subject matter
            of the controversy (dispute). """
            ),
            label_column="label",
            label_classes=SCDB_ISSUE_AREAS,
            multi_label=False,
            attributes=[
                ("decision_direction", ["conservative", "liberal"]),
                ("respondent_type", ["other", "person", "organization", "public entity", "facility"]),
            ],
            url="http://scdb.wustl.edu/data.php",
            data_url="https://zenodo.org/record/6322643/files/scotus.zip",
            citation=textwrap.dedent(
                """\
            @misc{spaeth2020,
             author = {Harold J. Spaeth and Lee Epstein and Andrew D. Martin, Jeffrey A. Segal
             and Theodore J. Ruger and Sara C. Benesh},
             year = {2020},
             title ={{Supreme Court Database, Version 2020 Release 01}},
             url= {http://Supremecourtdatabase.org},
             howpublished={Washington University Law}
            }"""
            ),
        ),
        FairlexConfig(
            name="fscs",
            description=textwrap.dedent(
                """\
            The Federal Supreme Court of Switzerland (FSCS) is the last level of appeal in Switzerland and similarly
            to SCOTUS, the court generally hears only the most controversial or otherwise complex cases which have
            not been sufficiently well solved by lower courts. The court often focus only on small parts of previous
            decision, where they discuss possible wrong reasoning by the lower court. The Swiss-Judgment-Predict
            dataset (Niklaus et al., 2021) contains more than 85K decisions from the FSCS written in one of three
            languages (50K German, 31K French, 4K Italian) from the years 2000 to 2020. The dataset is not parallel,
            i.e., all cases are unique and decisions are written only in a single language. The dataset provides labels
            for a simplified binary (approval, dismissal) classification task. Given the facts of the case, the goal
            is to predict if the plaintiff's request is valid or partially valid."""
            ),
            label_column="label",
            label_classes=FSCS_LABELS,
            multi_label=False,
            attributes=[
                ("decision_language", ["de", "fr", "it"]),
                ("legal_area", ["other", "public law", "penal law", "civil law", "social law", "insurance law"]),
                (
                    "court_region",
                    [
                        "n/a",
                        "Région lémanique",
                        "Zürich",
                        "Espace Mittelland",
                        "Northwestern Switzerland",
                        "Eastern Switzerland",
                        "Central Switzerland",
                        "Ticino",
                        "Federation",
                    ],
                ),
            ],
            url="https://github.com/JoelNiklaus/SwissCourtRulingCorpus",
            data_url="https://zenodo.org/record/6322643/files/fscs.zip",
            citation=textwrap.dedent(
                """\
            @InProceedings{niklaus-etal-2021-swiss,
              author = {Niklaus, Joel
                            and Chalkidis, Ilias
                            and Stürmer, Matthias},
              title = {Swiss-Court-Predict: A Multilingual Legal Judgment Prediction Benchmark},
              booktitle = {Proceedings of the 2021 Natural Legal Language Processing Workshop},
              year = {2021},
              location = {Punta Cana, Dominican Republic},
            }"""
            ),
        ),
        FairlexConfig(
            name="cail",
            description=textwrap.dedent(
                """\
            The Supreme People's Court of China (CAIL) is the last level of appeal in China and considers cases that
            originated from the high people's courts concerning matters of national importance. The Chinese AI and Law
            challenge (CAIL) dataset (Xiao et al., 2018) is a Chinese legal NLP dataset for judgment prediction and
            contains over 1m criminal cases. The dataset provides labels for relevant article of criminal code
            prediction, charge (type of crime) prediction, imprisonment term (period) prediction, and monetary penalty
            prediction. The updated (soft) version of the CAIL dataset has 104K criminal court cases. The tasks is
            crime severity prediction task, a multi-class classification task, where given the facts of a case,
            the goal is to predict how severe was the committed crime with respect to the imprisonment term.
            We approximate crime severity by the length of imprisonment term, split in 6 clusters
            (0, >=12, >=36, >=60, >=120, >120 months)."""
            ),
            label_column="label",
            label_classes=CAIL_LABELS,
            multi_label=False,
            attributes=[
                ("defendant_gender", ["male", "female"]),
                ("court_region", ["Beijing", "Liaoning", "Hunan", "Guangdong", "Sichuan", "Guangxi", "Zhejiang"]),
            ],
            url="https://github.com/thunlp/LegalPLMs",
            data_url="https://zenodo.org/record/6322643/files/cail.zip",
            citation=textwrap.dedent(
                """\
            @article{wang-etal-2021-equality,
                  title={Equality before the Law: Legal Judgment Consistency Analysis for Fairness},
                  author={Yuzhong Wang and Chaojun Xiao and Shirong Ma and Haoxi Zhong and Cunchao Tu and Tianyang Zhang and Zhiyuan Liu and Maosong Sun},
                  year={2021},
                  journal={Science China  - Information Sciences},
                  url={https://arxiv.org/abs/2103.13868}
            }"""
            ),
        ),
    ]

    def _info(self):
        features = {"text": datasets.Value("string")}
        if self.config.multi_label:
            features["labels"] = datasets.features.Sequence(datasets.ClassLabel(names=self.config.label_classes))
        else:
            features["label"] = datasets.ClassLabel(names=self.config.label_classes)
        for attribute_name, attribute_groups in self.config.attributes:
            features[attribute_name] = datasets.ClassLabel(names=attribute_groups)
        return datasets.DatasetInfo(
            description=self.config.description,
            features=datasets.Features(features),
            homepage=self.config.url,
            citation=self.config.citation + "\n" + MAIN_CITATION,
        )

    def _split_generators(self, dl_manager):
        data_dir = dl_manager.download_and_extract(self.config.data_url)
        return [
            datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                # These kwargs will be passed to _generate_examples
                gen_kwargs={
                    "filepath": os.path.join(data_dir, "train.jsonl"),
                    "split": "train",
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.TEST,
                # These kwargs will be passed to _generate_examples
                gen_kwargs={
                    "filepath": os.path.join(data_dir, "test.jsonl"),
                    "split": "test",
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.VALIDATION,
                # These kwargs will be passed to _generate_examples
                gen_kwargs={
                    "filepath": os.path.join(data_dir, "val.jsonl"),
                    "split": "val",
                },
            ),
        ]

    def _generate_examples(self, filepath, split):
        """This function returns the examples in the raw (text) form."""
        with open(filepath, encoding="utf-8") as f:
            for id_, row in enumerate(f):
                data = json.loads(row)
                example = {
                    "text": data["text"],
                    self.config.label_column: data[self.config.label_column],
                }
                for attribute_name, _ in self.config.attributes:
                    example[attribute_name] = data["attributes"][attribute_name]
                yield id_, example