#!/usr/bin/env python3

import sys
import os
import argparse
import random
import csv
import re
import logging
from tqdm import tqdm

logger = logging.getLogger()
logger.setLevel(logging.INFO)


REPLACEMENT_MAP = {
    'a': ['&', 'é', 'ã', '1', '2', 'z', 'q'],
    'ã': ['a', 'é', '&', '"', 'a', 'z', '1', '2', '3'],
    'à': ['a', 'è', '-', '_', '\\', 'y', 'u', '6', '7', '8'],
    'ä': ['a', 'â', 'p', 'm', '$', '£', ')', ']', '=', '}', 'º', '+', '%', 'ù'],
    'â': ['a', 'ä', 'p', 'm', '$', '£', ')', ']', '=', '}', 'º', '+', '%', 'ù'],
    'b': ['v', 'n', 'g', 'h'],
    'c': ['x', 'v', 'f', 'g'],
    'ç': ['c', '_', '\\', 'à', '@', 'i', 'o', '8', '9', '0'],
    'd': ['s', 'f', 'e', '€', 'r', 'x', 'c'],
    'e': ['€', 'z', 'r', 's', 'd', '"', '#', '\'', '{', '3', '4'],
    'é': ['e', '€', 'ã', '&', '"', 'a', 'z', '1', '2', '3'],
    'ê': ['e', '€', 'z', 'r', 's', 'd', '"', '#', '\'', '{'],
    'è': ['e', '€', 'à', '-', '_', '\\', 'y', 'u', '6', '7', '8'],
    'f': ['d', 'g', 'r', 't', 'c', 'v'],
    'g': ['f', 'h', 't', 'y', 'v', 'b'],
    'h': ['g', 'j', 'y', 'u', 'b', 'n'],
    'i': ['u', 'o', '_', '\\', 'ç', '^', 'j', 'k', '8', '9'],
    'j': ['h', 'k', 'u', 'i', 'n', '?', ','],
    'k': ['j', 'l', 'i', 'o', '?', ',', '.', ';'],
    'l': ['k', 'm', 'o', 'p', '.', ';', '/', ':'],
    'm': ['l', '%', 'ù', 'p', 'ä', 'â', '/', ':', '§', '!'],
    'n': ['b', '?', ',', 'h', 'j'],
    'o': ['i', 'p', 'ç', '^', 'à', '@', 'k', 'l', '9', '0'],
    'p': ['o', 'ä', 'â', 'à', '@', ')', ']', 'l', 'm', '0', 'º'],
    'q': ['a', 'z', 's', 'w', '>', '<'],
    'r': ['e', 't', 'd', 'f', '\'', '{', '(', '[', '4', '5'],
    's': ['q', 'd', 'z', 'w', 'x'],
    't': ['r', 'y', 'f', 'g', '(', '[', '-', '5', '6'],
    'u': ['y', 'i', 'h', 'j', 'è', 'à', '_', '\\', '7', '8'],
    'ù': ['u', '%', 'm', 'ä', 'â', '§', '!', '$', '£'],
    'v': ['c', 'b', 'f', 'g'],
    'x': ['w', 'c', 's', 'd'],
    'y': ['t', 'u', 'g', 'h', '_', 'è', 'à', '6', '7'],
    'w': ['>', '<', 'x', 'q', 's'],
    'z': ['a', 'e', '€', 'q', 's', 'é', 'ã', '"', '#', '2', '3'], 
}


SENTENCE_ID = re.compile(r'^\d+\t')


def rotate(word: str) -> str:
    if len(word) < 3:
        return word
    i = random.randint(1, len(word) - 2)
    j = i + 1 if random.random() > 0.5 else i - 1
    letters = list(word)
    letters[i], letters[j] = letters[j], letters[i]
    word_ = ''.join(letters)
    return word_


def replace(word: str) -> str:
    word_ = '%s' % word
    i = random.randint(0, len(word) - 1)
    is_lower = word[i].lower() == word[i]
    if word[i].lower() in REPLACEMENT_MAP:
        c = random.choice(REPLACEMENT_MAP[word[i].lower()])
        c = c if is_lower else c.upper()
        letters = list(word)
        letters[i] = c
        word_ = ''.join(letters)
    return word_


def insert(word: str) -> str:
    i = random.randint(0, len(word) - 1)
    c = word[i]
    j = i + 1 if random.random() > 0.5 else i - 1
    letters = list(word)
    letters.insert(j, c)
    word_ = ''.join(letters)
    return word_


def delete(word: str) -> str:
    i = random.randint(0, len(word) - 1)
    word_ = word[:i] + word[i + 1:]
    return word_


OPERATIONS = [
    rotate,
    insert,
    delete,
    replace
]


def transform_sentence(sentence: str, probability: float = 0.25) -> str:
    words = sentence.split()

    # Join two words with probability 0.5
    if random.random() < 0.5 and len(words) > 1:
        i = random.randint(0, len(words) - 1)
        if random.random() < 0.5 and i < len(words) - 1 or i == 0:
            j = i + 1
            words[i] = f"{words[i]}{words[j]}"
        else:
            j = i - 1
            words[i] = f"{words[j]}{words[i]}"
        del words[j]

    # Transform each word with probability 'probability'
    for i, word in enumerate(words):
        if random.random() < probability and not word.isdigit():
            words[i] = random.choice(OPERATIONS)(word)
    sentence_ = ' '.join(words)
    return sentence_


def main(args: argparse.Namespace) -> int:
    if not os.path.exists(args.input_data_path):
        logger.error("Invalid input data path.")
        return -1
    
    sentences = []
    with open(args.input_data_path, 'r') as f:
        for sentence in f:
            if SENTENCE_ID.search(sentence):
                sentence = SENTENCE_ID.sub('', sentence)
            sentence = (
                sentence
                .replace('“', '')
                .replace('”', '')
                .replace('"', '')
                .replace('«', '')
                .replace('»', '')
            )   
            sentences.append(' '.join(sentence.split()))

    dirname = os.path.dirname(args.output_data_path)
    if not os.path.exists(dirname):
        os.mkdir(dirname)

    logger.info("Transforming sentences to generate cases")
    with open(args.output_data_path, 'w', newline='') as csv_file:
        writer = csv.writer(csv_file, delimiter=',')
        writer.writerow(["input", "target"])
        for sentence in tqdm(sentences):
            correction = sentence
            for case in range(args.number_of_cases):
                transformed_sentence = transform_sentence(sentence)
                if transformed_sentence == sentence:
                    continue
                input_text = f"grammaire: {transformed_sentence}"
                writer.writerow([input_text, correction])

    return 0


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument(
        '--input-data-path', '-i',
        type=str,
        required=True
    )
    parser.add_argument(
        '--output-data-path', '-o',
        type=str,
        default='data/dataset/dataset.csv'
    )
    parser.add_argument(
        '--number-of-cases', '-n',
        type=int,
        default=5
    )

    args, _ = parser.parse_known_args()

    sys.exit(
        main(args)
    )