import torch
import logging
from transformers import BertModel, BertTokenizerFast
import os
from pathlib import Path
import pandas as pd
from datasets import load_dataset
from torch.utils.data import DataLoader
from tqdm import tqdm

CURRENT_PATH = Path(__file__).parent


def tokenize(dataset):
    BERT_MAX_LEN = 512

    tokenizer = BertTokenizerFast.from_pretrained(
        "neuralmind/bert-base-portuguese-cased", max_length=BERT_MAX_LEN)

    dataset = dataset.map(lambda example: tokenizer(
        example["text"], truncation=True, padding="max_length", max_length=BERT_MAX_LEN))

    return dataset


def create_dataloader(dataset, shuffle=True):
    return DataLoader(dataset, batch_size=8, shuffle=shuffle, num_workers=8, drop_last=True)


class AutoEncoder(torch.nn.Module):
    def __init__(self):
        super().__init__()

        self.device = torch.device(
            'cuda' if torch.cuda.is_available() else 'cpu')

        self.bert = BertModel.from_pretrained(
            'neuralmind/bert-base-portuguese-cased').to(self.device)

        # Freeze BERT
        for param in self.bert.parameters():
            param.requires_grad = False

        self.encoder = torch.nn.Sequential(
            torch.nn.Linear(self.bert.config.hidden_size,
                            self.bert.config.hidden_size // 5),
            torch.nn.ReLU(),
            torch.nn.Linear(self.bert.config.hidden_size // 5,
                            self.bert.config.hidden_size // 10),
            torch.nn.ReLU(),
            torch.nn.Linear(self.bert.config.hidden_size // 10,
                            self.bert.config.hidden_size // 30),
            torch.nn.ReLU(),
        ).to(self.device)

        self.decoder = torch.nn.Sequential(
            torch.nn.Linear(self.bert.config.hidden_size // 30,
                            self.bert.config.hidden_size // 10),
            torch.nn.ReLU(),
            torch.nn.Linear(self.bert.config.hidden_size // 10,
                            self.bert.config.hidden_size // 5),
            torch.nn.ReLU(),
            torch.nn.Linear(self.bert.config.hidden_size //
                            5, self.bert.config.hidden_size),
            torch.nn.Sigmoid()
        ).to(self.device)

    def forward(self, input_ids, attention_mask):
        bert_output = self.bert(input_ids=input_ids,
                                attention_mask=attention_mask).last_hidden_state[:, 0, :]

        encoded = self.encoder(bert_output)

        decoded = self.decoder(encoded)

        return bert_output, decoded


def load_models():
    models = []

    for domain in ['politics', 'news', 'law', 'social_media', 'literature', 'web']:
        logging.info(f"Loading {domain} model...")

        accumulator = []

        for lang in ['brazilian', 'european']:
            model = AutoEncoder()
            model.load_state_dict(torch.load(os.path.join(
                CURRENT_PATH, 'models', 'autoencoder', f'{domain}_{lang}_model.pt')))
            accumulator.append(model)

        models.append({
            'models': accumulator,
            'train_domain': domain,
        })

    return models


def benchmark(model, debug=False):

    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

    df_results = pd.DataFrame(
        columns=['train_domain', 'test_domain', 'accuracy', 'f1', 'precision', 'recall'])

    train_domain = model['train_domain']

    brazilian_model = model['models'][0]

    european_model = model['models'][1]

    brazilian_model.eval()
    european_model.eval()

    brazilian_model.to(device)
    european_model.to(device)

    for test_domain in ['politics', 'news', 'law', 'social_media', 'literature', 'web']:
        dataset = load_dataset(
            'arubenruben/Portuguese_Language_Identification', test_domain, split='test')

        if debug:
            logging.info(f"Debugging {test_domain} dataset...")
            dataset = dataset.select(range(100))
        else:
            dataset = dataset.shuffle().select(range(min(50_000, len(dataset))))

        dataset = tokenize(dataset)

        dataset.set_format(type='torch', columns=[
                           'input_ids', 'attention_mask', 'label'])

        dataset = create_dataloader(dataset)

        predictions = []
        labels = []

        reconstruction_loss = torch.nn.MSELoss(reduction='none')

        with torch.no_grad():
            for batch in tqdm(dataset):
                input_ids = batch['input_ids'].to(device)

                attention_mask = batch['attention_mask'].to(device)

                label = batch['label'].to(device)

                bert_european, reconstruction_european = european_model(
                    input_ids=input_ids, attention_mask=attention_mask)
                
                bert_brazilian, reconstruction_brazilian = brazilian_model(
                    input_ids=input_ids, attention_mask=attention_mask)

                test_loss_european = reconstruction_loss(
                    reconstruction_european, bert_european)

                test_loss_brazilian = reconstruction_loss(
                    reconstruction_brazilian, bert_brazilian)

                for loss_european, loss_brazilian in zip(test_loss_european, test_loss_brazilian):

                    if loss_european.mean().item() < loss_brazilian.mean().item():
                        predictions.append(0)
                        total_loss += loss_european.mean().item() / len(test_loss_european)

                    else:
                        predictions.append(1)
                        total_loss += loss_brazilian.mean().item() / len(test_loss_brazilian)

                labels.extend(label.tolist())

        accuracy = accuracy.compute(
            predictions=predictions, references=labels)['accuracy']
        f1 = f1.compute(predictions=predictions, references=labels)['f1']
        precision = precision.compute(
            predictions=predictions, references=labels)['precision']
        recall = recall.compute(predictions=predictions,
                                references=labels)['recall']

        df_results = pd.concat([df_results, pd.DataFrame(
            [[train_domain, test_domain, accuracy, f1, precision, recall]], columns=df_results.columns)], ignore_index=True)

    return df_results


def test():
    DEBUG = True

    models = load_models()

    df_results = pd.DataFrame(
        columns=['train_domain', 'test_domain', 'accuracy', 'f1', 'precision', 'recall'])

    for model in models:
        logging.info(f"Train Domain {model['train_domain']}...")

        df_results = pd.concat([df_results, benchmark(
            model, debug=DEBUG)], ignore_index=True)

        logging.info(f"Saving results...")

        df_results.to_json(os.path.join(CURRENT_PATH, 'results',
                           'autoencoder.json'), orient='records', indent=4, force_ascii=False)


if __name__ == '__main__':
    test()