#!/bin/python3
import os
import re
import shutil
from datetime import datetime
import unicodedata

from website_config import *

# this path should be customized
org_roam_dir: str = '/home/tykayn/Nextcloud/textes/orgmode/org-roam/'

# Trouver l'identifiant OrgROAM
pattern_roam_id_search = r':ID:(?:\s+)?([a-zA-Z0-9-]+)'
# Expression régulière pour extraire la date et le slug du nom de fichier org
regex = r"^([a-zA-Z0-9_-]+)\_\_(-[a-zA-Z0-9_-]+)\.org$"
# Recherche de date de création du fichier org-roam dans un article gemini
regex_orgroam = regex

# show_logs=True
show_logs = global_config["show_logs"]


def mylog(*content):
    """Fonction qui imprime tous les arguments passés selon le niveau de debug souhaité."""
    if show_logs:
        for c in content:
            print('    ',c)


def trouver_nom_article(fichier_org, blog_name, format="html"):
    mylog('fichier_org, ', fichier_org)
    with open(fichier_org, 'r') as file:
        lignes = file.readlines()

    nom_article = ''

    mylog('trouver_nom_article format', format)
    # Expressions régulières pour trouver les titres de niveau 1 et 2
    if format == 'html':
        titre_niveau_1 = r'<h1\s+(?:id|data-created)="[^"]*">(.*?)</h1>'
        titre_niveau_2 = r'^\<h2.*?\>(.+)\<\/h2\>$'
    else:
        titre_niveau_1 = r'^\*+ (.+)$'
        titre_niveau_2 = r'^\*\*+ (.+)$'

    # Itérer sur les lignes du fichier
    for ligne in lignes:
        # Rechercher un titre de niveau 1
        titre_niveau_1_match = re.match(titre_niveau_1, ligne)
        if titre_niveau_1_match:
            titre_niveau_1_texte = titre_niveau_1_match.group(1)
            if titre_niveau_1_texte.lower() != "article" and titre_niveau_1_texte.lower() != "liens":
                nom_article = titre_niveau_1_texte
                break
            else:
                # Si le premier titre de niveau 1 est "Article", rechercher le premier titre de niveau 2
                titre_niveau_2_match = re.match(titre_niveau_2, ligne)
                if titre_niveau_2_match:
                    nom_article = titre_niveau_2_match.group(1)
                    break
    mylog(f"Nom de l'article : {nom_article}")

    return nom_article.replace(blog_name + '_', '').replace('_', ' ')


def find_year_and_slug_on_filename(fichier):
    fichier = fichier.replace('..', '.')
    # mylog(f" ------------ find_year_and_slug in {fichier} -------------")
    slug = ''
    annee = '2024'
    date_str = '2024-00-00'
    date = '2024-00-00'
    boom = fichier.split('__')
    # print(boom)

    if boom :
        date_str = boom[0]
        annee = date_str[:4]
        slug = boom[1].replace('.org', '')
        # date = datetime.strptime(date_str, "%Y%m%dT%H%M%S")

        # Convertir la date en objet datetime
        if "-" in date_str:
            slug = enlever_premier_tiret_ou_underscore(slug)

        # mylog(f" find_year_and_slug : Fichier: {fichier}")
        # mylog(f" find_year_and_slug : année: {annee}")
        # mylog(f" find_year_and_slug : str(date): {str(date)}")
        # mylog(f" find_year_and_slug : slug: {slug}")
        mylog(f" find_year_and_slug : chemin: {annee}/{slug}/")
        return [date_str, annee, slug]
    return [date_str, annee, fichier.replace(' ', '-').replace('.org', '')]


def enlever_premier_tiret_ou_underscore(chaîne):
    if chaîne.startswith('-') or chaîne.startswith('_'):
        chaîne = chaîne[1:]
    return chaîne


# création des dossiers intermédiaires s'il y en a
# déplace le fichier dans le dossier spécifié
def create_path_folders_and_move_file(path, file):
    os.makedirs(os.path.dirname(path), exist_ok=True)

    shutil.move(file, path)


def get_files_list_of_folder(folder_path):
    # Vérifie si le dossier existe
    if not os.path.exists(folder_path):
        print(f" ------------ build_indexes: Erreur : Le dossier '{folder_path}' n'existe pas.")
        return
    mylog('----------- get_files_list_of_folder: folder_path : ', folder_path)
    # Liste les fichiers articles, trie par nom décroissant
    try:
        fichiers_md = sorted(
            [f.replace('.' + global_config['source_files_extension'], '.gmi') for f in os.listdir(folder_path) if
             f.endswith(global_config['source_files_extension'])], reverse=True)
        print('fichiers trouvés:', len(fichiers_md))
        return fichiers_md
    except OSError as e:
        print(f" ------------ build_indexes: Erreur lors de la lecture du dossier : {e}")
        return


def get_id_of_roam_note_content(content):
    match = re.search(pattern_roam_id_search, content)
    if match:
        return match.group(1)
    return None


def find_first_level1_title(content):
    pattern = r'^\* (.+)$'
    match = re.search(pattern, content, re.MULTILINE)
    if match:
        if match.group(1) != 'Article':
            return match.group(1)
        else:
            pattern = r'^\*\* (.+)$'
            match = re.search(pattern, content, re.MULTILINE)
            if match:
                return match.group(1)
    return None

def find_extract_in_content_org(org_content):
    # Supprimer les lignes qui commencent par #+
    org_content = re.sub(r'^\s*#\+.*\n', '', org_content, flags=re.MULTILINE)

    # Supprimer les sections de logbook
    org_content = re.sub(r'^\*\* Logbook\n.*?(?=\*\* |\Z)', '', org_content, flags=re.DOTALL | re.MULTILINE)

    # Supprimer les propriétés
    org_content = re.sub(r'^:PROPERTIES:\n.*?:END:\n', '', org_content, flags=re.DOTALL | re.MULTILINE)

    # Supprimer les lignes vides supplémentaires
    org_content = re.sub(r'\n\s*\n+', '\n', org_content)

    # Supprimer les espaces en début et fin de chaque ligne
    org_content = '\n'.join(line.strip() for line in org_content.splitlines())

    # Supprimer les espaces en début et fin du contenu final
    return org_content.strip()

def extract_body_content(html_content):
    pattern = r'<body.*?>(.*?)</body>'
    match = re.search(pattern, html_content, re.DOTALL)
    if match:
        return match.group(1)
    else:
        print('---- extract_body_content : no body found in this html')
        return html_content

def add_tags_from_content(tags=None, file_content="", words_to_check=None):
    """
    Ajoute des tags à l'ensemble `tags` si les mots correspondants sont trouvés dans le contenu du fichier.

    :param tags: Ensemble de tags (set). Si None, un nouvel ensemble est créé (type set, optionnel).
    :param file_content: Contenu du fichier (str).
    :param words_to_check: Liste de mots à repérer (list). Si None, une liste vide est utilisée (type list, optionnel).
    :return: Ensemble de tags mis à jour (set).
    """
    # Initialiser l'ensemble tags s'il est None
    if tags is None:
        tags = set()

    # Initialiser la liste words_to_check s'il est None
    if words_to_check is None:
        words_to_check = []

    # Convertir le contenu du fichier en minuscules pour une recherche insensible à la casse
    file_content_lower = file_content.lower()

    # Parcourir chaque mot à vérifier
    for word in words_to_check:
        # Vérifier si le mot est présent dans le contenu du fichier
        if word.lower() in file_content_lower:
            # Ajouter le tag correspondant à l'ensemble de tags
            tags.add(word)

    return tags

def extract_tags_from_file(file_path, excluded_tags):
    tags = set()
    with open(file_path, 'r', encoding='utf-8') as file_content:
        tag_found = False
        for line in file_content:
            if global_config['automatic_tagging_enabled']:
                tags = add_tags_from_content(tags, line, global_config['auto_tag_terms'])
            # Check for orgmode tags :tag1:tag2:
            if ':' in line:
                for word in line.split():
                    if len(word) and word.startswith(':') and word.endswith(':'):
                        tag = word[1:-1]
                        if tag not in excluded_tags:
                            tags.add(tag)
                            tag_found = True
            # Check for #+tags: tag1,tag2
            if line.startswith('#+tags:'):
                for tag in line[len('#+tags:'):].split(','):
                    tag = tag.strip()
                    if tag and tag not in excluded_tags:
                        tags.add(tag)
                        tag_found = True

    if not tag_found:
        print('no tag in the article', file_path)
    return tags

def remove_properties_section(text):
    pattern = r"<h1 id=\"article\">Article</h1>.+?</ul>"
    replacement = ""
    return re.sub(pattern, replacement, text, flags=re.DOTALL)


def remove_article_head_properties_orgmode(text):
    pattern = r":PROPERTIES:.+?:END:"
    replacement = ""
    return re.sub(pattern, replacement, text, flags=re.DOTALL)


def remove_hint_html(text):
    pattern = r"<p>ceci<sub>estduhtml</sub></p>"
    replacement = ""
    return re.sub(pattern, replacement, text, flags=re.DOTALL)


def slugify_title(title_text):
    """
    Transforme un titre en un slug valide.

    :param title_text: Titre en texte (str).
    :return: Slug en minuscules avec des tirets (str).
    """
    title_text = unicodedata.normalize('NFKD', title_text).encode('ascii', 'ignore').decode('ascii')
    title_text = title_text.lower()
    title_text = re.sub(r'[^a-z0-9\s-]', '', title_text)
    title_text = re.sub(r'\s+', '-', title_text)
    title_text = re.sub(r'-+', '-', title_text)
    title_text = title_text.strip('-')
    return title_text

def find_slug_in_file_basename(file_basename) -> str:
    """
    Extrait l'année et le slug du nom de fichier selon le format spécifié.

    :param file_basename: Nom de fichier (str).
    :return: Tuple contenant l'année et le slug (année, slug) ou None si non trouvé.
    """
    pattern = regex_orgroam
    match = re.match(pattern, file_basename)
    if match:
        year = match.group(1)
        slug = match.group(2)
        # prendre la partie finale du nom du fichier
        splitted = slug.split('_')
        # print('len(splitted)', len(splitted), splitted)
        if len(splitted) > 1:
            slug = splitted[len(splitted)-1]

        # final_slug=slug.replace("_cipherbliss_blog_","")
        # final_slug=final_slug.replace("_blog_cil_gometz_","")
        slug=enlever_premier_tiret_ou_underscore(slug)

        slug = f"{year}/{slug}"



        return slug
    return None