import html
import os
import re
import shutil
from collections import defaultdict

SRC_DIR = "src"
DST_DIR = "dst"
IMG_DIR = "img"
INCLUDE_DIR = "inc"

os.makedirs(DST_DIR, exist_ok=True)

def copy_file(src, dst):
    try:
        shutil.copy(src, dst)
    except FileNotFoundError:
        print(f"Warning: {src} not found. Skipping.")

def copy_folder(src, dst):
    try:
        if os.path.exists(dst):
            shutil.rmtree(dst)
        shutil.copytree(src, dst)
    except Exception as e:
        print(f"Error copying folder {src} to {dst}: {e}")

def read_file(filepath, encoding="utf-8"):
    try:
        with open(filepath, "r", encoding=encoding) as file:
            return file.read()
    except FileNotFoundError:
        print(f"Warning: {filepath} not found.")
        return ""

def write_file(filepath, content, encoding="utf-8"):
    with open(filepath, "w", encoding=encoding) as file:
        file.write(content)

def set_permissions(DST_DIR):
    for root, dirs, files in os.walk(DST_DIR):
        for dir_name in dirs:
            dir_path = os.path.join(root, dir_name)
            os.chmod(dir_path, 0o755)

        for file_name in files:
            file_path = os.path.join(root, file_name)
            os.chmod(file_path, 0o644)

backlink_map = defaultdict(set)


def find_internal_links(text, current_file):
    re.sub(r"{([a-zA-Z0-9_]+)(?:\s+([^}]*))?}", 
           lambda m: backlink_map[m.group(1)].add(current_file), 
           text)

def process_internal_links(text):
    return re.sub(
        r"{([a-zA-Z0-9_]+)(?:\s+([^}]+))?}",
        lambda m: f'<a href="{m.group(1)}.html">{m.group(2) if m.group(2) else m.group(1)}</a>',
        text,)

def include_image(image_file):
    for ext in ["jpg", "png"]:
        img_path = os.path.join(IMG_DIR, f"{image_file}.{ext}")
        if os.path.exists(img_path):
            return f'<img src="{img_path}" alt="{image_file}.{ext}">'
    return ""

def include_file(file_type, reference):
    dir_map = {"code": "code", "text": "text"}

    parts = reference.split(":")
    filename = parts[0]
    line_ranges = parts[1:]

    file_path = os.path.join(
        INCLUDE_DIR, dir_map[file_type], filename if file_type == "code" else f"{filename}.txt"
    )

    content = read_file(file_path)
    if not content:
        return f"<pre><code>File not found: {filename}</code></n"

    if not line_ranges:
        return f'<pre><code>==> <a href="{file_path}" target="_blank">{file_path}</a></code></pre>'

    content_lines = content.splitlines()
    selected_lines = []
    for line_range in line_ranges:
        try:
            if "-" in line_range:
                start, end = map(int, line_range.split("-"))
                selected_lines.append("\n".join(content_lines[start - 1:end]))
            else:
                line = int(line_range)
                selected_lines.append(content_lines[line - 1])
        except (ValueError, IndexError):
            selected_lines.append(f"Error processing range: {line_range}")

    formatted_content = "\n\n[...]\n\n".join(selected_lines)

    escaped_content = html.escape(formatted_content)

    return f"<pre><section><a href=\"{file_path}\">{file_path}</a></section>\n<code>{escaped_content}</code></pre>"

def convert_inline_markup(text):
    text = re.sub(
        r"`(.*?)`", 
        lambda m: f"<code>{html.escape(m.group(1))}</code>", 
        text
    )
    text = re.sub(r"\*(.*?)\*", r"<strong>\1</strong>", text)
    text = re.sub(r"~(.*?)~", r"<em>\1</em>", text)
    text = re.sub(r"`(.*?)`", r"<code>\1</code>", text)

    text = re.sub(r"(?<!href=['\"])(?<![<])=(.*?)(?!=)(?<!['\"]>)=(?!>)",r"<mark>\1</mark>",text)
    return text

def handle_list(html_lines, line, in_list):
    if not in_list:
        html_lines.append("<ul>")
    html_lines.append(f"<li>{convert_inline_markup(line[2:])}</li>")
    return True

def handle_table(html_lines, line, in_table):
    if not in_table:
        html_lines.append("<table>")
    rows = "".join([f"<td>{convert_inline_markup(cell.strip())}</td>" for cell in line.split("|") if cell.strip()])
    html_lines.append(f"<tr>{rows}</tr>")
    return True

def handle_backlinks(filename):
    backlinks = backlink_map.get(filename, [])
    if not backlinks:
        return ""
    links = "".join(
        f'<li><a href="{backlink}.html">{read_file(os.path.join(SRC_DIR, f"{backlink}.txt")).splitlines()[0]}</a> <em>- {read_file(os.path.join(SRC_DIR, f"{backlink}.txt")).splitlines()[2]}</em></li>'
        for backlink in sorted(backlinks)
    )
    return f"<section style='border-left:1px solid black;padding:.5rem;margin-bottom:.5rem;'><b>Connexion(s):</b><ul>{links}</ul></section>"

def handle_external_link(line, in_list):
    parts = line.split("::")
    if len(parts) == 2:
        text, url = parts[0].strip(), parts[1].strip()
        return f'<a href="{url}" target="_blank">{text}</a>'
    return line

def convert_markup_to_html(markup_lines, filename):
    html_lines = []
    previous_line_type = ""
    in_list, in_table, in_blockcode = False, False, False
    block_code_buffer = []

    if len(markup_lines) < 2:
        print(f"Skipping {filename}: insufficient content.")
        return ""
    title, subtitle = markup_lines[0].strip(), markup_lines[2].strip()

    html_lines.append(
        read_file(os.path.join(INCLUDE_DIR, "head.tpl")).replace("{title}", title)
    )
    html_lines += [
        "<main>",
        f"<h1>{title}</h1>",
        f"<sub>{subtitle}</sub>",
        include_image(f"headers/{filename}"),
        "<article>",
    ]

    if filename =="home":
	    html_lines.append("<p>Bienvenue à toi explorateur de l'internet artisanal !</p>\n<p>Tu te trouves ici dans un espace numérique de partage, une expérience faite de mots, de notes et de vents.</p>\n<p>En perpetuel mouvement, le site évolue, avec ses pics d'activités et ses temps morts.</p>\n<p>Cette page sert de point d'ancrage à plusieurs notions traversant l'ensemble des notes, il regroupe ainsi les différentes structure notes au sein d'<a href=\"iomlan.html\">iomlan</a>.</p>\n<p>Bonne exploration !</p>")

    for line in markup_lines[3:]:
        line = line.strip()  # Remove whitespace
        line = process_internal_links(line)  # Process internal links

        if line == "```":
            in_blockcode = not in_blockcode
            if not in_blockcode:  # End block code
                html_lines.append("<pre><code>" + "\n".join(block_code_buffer) + "</code></pre>")
                block_code_buffer = []
            continue
        if in_blockcode:
            block_code_buffer.append(line)
            continue

        if not line:
            if in_list:
                html_lines.append("</ul>")
                in_list = False
            if in_table:
                html_lines.append("</table>")
                in_table = False
            continue

        if line.startswith("{^code "):
            html_lines.append(include_file("code", line[7:-1].strip()))
        elif line.startswith("{^img "):
            html_lines.append(include_image(line[6:-1].strip()))
        elif line.startswith("{^text "):
            html_lines.append(include_file("text", line[7:-1].strip()))
        elif line.startswith("+ "):  # Unordered list
            in_list = handle_list(html_lines, line, in_list)
        elif "|" in line:  # Table rows
            in_table = handle_table(html_lines, line, in_table)
        elif line.startswith("## "):  # Heading level 2
            html_lines.append(f"<h2>{line[3:]}</h2>")
        elif line.startswith("### "):  # Heading level 3
            html_lines.append(f"<h3>{line[4:]}</h3>")
        elif line.startswith('"') and line.endswith('"'):
            html_lines.append(f"<blockquote>« {line[1:-1]} »</blockquote>")
            previous_line_type = "blockquote"
        elif line.startswith("-") and previous_line_type == "blockquote":
            html_lines.append(f"<cite>{line[1:].strip()}</cite>")
        elif line.startswith("---"):
            html_lines.append(f"<hr>")
        elif "::" in line:
            if not in_list:
                html_lines.append("<ul>")
                in_list = True
            html_lines.append(f"<li>{handle_external_link(line, in_list)}</li>")
        elif ";;" in line:
            text, description = map(str.strip, line.split(";;", 1))
            if not in_list:
                html_lines.append("<ul>")
                in_list = True
            html_lines.append(
                f"<li><mark><strong>{text[2:] if text.startswith('! ') else text}</strong> <em>{description}</em></mark></li>"
                if text.startswith("! ")
                else f"<li><strong>{text}</strong> <em>{description}</em></li>"
            )
        elif line.startswith("#SN"):
             continue
        else:
            if in_list:
                html_lines.append("</ul>")
                in_list = False
            if in_table:
                html_lines.append("</table>")
                in_table = False
            html_lines.append(f"<p>{convert_inline_markup(line)}</p>")

    if in_list:
        html_lines.append("</ul>")
    if in_table:
        html_lines.append("</table>")
    if in_blockcode:
        html_lines.append("<pre><code>" + "\n".join(block_code_buffer) + "</code></pre>")

    html_lines.append(handle_backlinks(filename))
    html_lines.append('<a href="#">Back to top</a>')
    html_lines += ["</article>", "</main>"]
    html_lines.append(read_file(os.path.join(INCLUDE_DIR, "foot.tpl")))

    return "\n".join(html_lines)

for file in os.listdir(SRC_DIR):
    if file.endswith(".txt"):
        content = read_file(os.path.join(SRC_DIR, file))
        find_internal_links(content, os.path.splitext(file)[0])

for file in os.listdir(SRC_DIR):
    if file.endswith(".txt"):
        lines = read_file(os.path.join(SRC_DIR, file)).splitlines()
        html_content = convert_markup_to_html(lines, os.path.splitext(file)[0])
        write_file(os.path.join(DST_DIR, file.replace(".txt", ".html")), html_content)

copy_file(os.path.join(INCLUDE_DIR, "style.css"), os.path.join(DST_DIR, "style.css"))
copy_file(os.path.join(INCLUDE_DIR, "atom.xsl"), os.path.join(DST_DIR, "atom.xsl"))
copy_folder(INCLUDE_DIR, os.path.join(DST_DIR, "inc"))
set_permissions(DST_DIR)