from __future__ import annotations
import logging
import shutil
from pathlib import Path
import os
import markdown
from typing import Optional, Union, Dict, Generator, List
from bs4 import BeautifulSoup

from .config import SOURCE_DIRECTORY, DIST_DIRECTORY, LANGUAGE_INFORMATION, ARTICLE_PREVIEW_LENGTH, DEFAULT_LANGUAGE



def replace_values(template: str, values: Dict[str, str]) -> str:
    for key, value in values.items():
        template = template.replace("{" + key + "}", value)

    return template


def get_first_header_content(content):
    soup = BeautifulSoup(content, 'html.parser')
    for level in range(1, 7):
        header = soup.find(f'h{level}')
        if header:
            return header.get_text(strip=True)

    return self.language_code.native_name


class Template:
    def __init__(self, folder: Path):
        self.folder = folder

        self.article: str = (self.folder / "article.html").read_text()
        self.overview: str = (self.folder / "overview.html").read_text()
        self.overview_card: str = (self.folder / "overview_card.html").read_text()



class ArticleTranslation:
    def __init__(self, file: Path, article_overview: ArticleOverview):
        self.file = file
        self.article_overview = article_overview
        self.language_code = self.file.stem

        self.article_content = self.file.read_text()
        if self.file.suffix == ".md":
            self.article_content = markdown.markdown(self.article_content)

        self.url = "/" + self.language_code + self.article_overview.url
        self.dist_path = Path(DIST_DIRECTORY, self.url.strip("/"))

        _language_info = DEFAULT_LANGUAGE
        parsed_language_code = self.language_code.lower().replace("-", "_")
        if parsed_language_code in LANGUAGE_INFORMATION:
            _language_info = LANGUAGE_INFORMATION[parsed_language_code]
        elif parsed_language_code.split("_")[0] in LANGUAGE_INFORMATION:
            _language_info = LANGUAGE_INFORMATION[parsed_language_code.split("_")[0]]

        self.language_name: str = _language_info["native_name"]
        self.language_flag: str = _language_info["flag"]
        self.priority: int = _language_info.get("priority", 0)

    
    def build(self):
        self.dist_path.mkdir(parents=True, exist_ok=True)

        with Path(self.dist_path, "index.html").open("w") as f:
            f.write(self.get_article())

    def _get_values(self) -> Dict[str, str]:
        return {
            "article_content": self.article_content,
            "article_preview": self.article_content[:ARTICLE_PREVIEW_LENGTH] + "...",
            "article_overview_url": self.article_overview.url,
            "article_href": self.url,
            "article_title": get_first_header_content(self.article_content),
            "article_language_name": self.language_name,
            "article_language_code": self.language_code,
            "article_language_flag": self.language_flag,
        }

    def get_article(self) -> str:
        global TEMPLATE
        return replace_values(TEMPLATE.article, self._get_values())

    def get_overview_card(self) -> str:
        global TEMPLATE
        return replace_values(TEMPLATE.overview_card, self._get_values())


class ArticleOverview:
    def __init__(self, directory: Path, url: str = ""):
        self.directory = directory
        self.slug = self.directory.name

        if self.slug in ARTICLE_LAKE:
            logger.error("two articles have the same name at %s and %r", ARTICLE_LAKE[self.slug].directory, self.directory)
            exit(1)
        ARTICLE_LAKE[self.slug] = self

        self.url = url + "/" + self.slug
        self.dist_path = Path(DIST_DIRECTORY, self.url.strip("/"))

        self.child_articles: List[ArticleOverview] = []
        self.article_translations: List[ArticleTranslation] = []

        for c in self.directory.iterdir():
            if c.is_file():
                self.article_translations.append(ArticleTranslation(c, self))
            elif c.is_dir():
                self.child_articles.append(ArticleOverview(c, self.url))

        # the tree is built
        self.article_translations.sort(key=lambda a: a.priority, reverse=True)
        self.overview_cards = "\n".join(a.get_overview_card() for a in self.article_translations)

    def build(self):
        # builds the tree structure to the dist directory
        self.dist_path.mkdir(parents=True, exist_ok=True)
        with Path(self.dist_path, "index.html").open("w") as f:
            f.write(self.get_overview())

        for at in self.article_translations:
            at.build()

        for ca in self.child_articles:
            ca.build()

    def _get_values(self) -> Dict[str, str]:
        return {
            "overview_cards": self.overview_cards,
            "overview_slug": self.slug,
        }

    def get_overview(self) -> str:
        global TEMPLATE
        return replace_values(TEMPLATE.overview, self._get_values())
    

def copy_static():
    src = str(Path(SOURCE_DIRECTORY, "static"))
    dst = str(Path(DIST_DIRECTORY, "static"))


    if not os.path.exists(src):
        logger.warn("The static folder '%s' wasn't defined.", src)
        return

    logger.info("copying static files from '%s' to '%r'", src, dst) 

    os.makedirs(dst, exist_ok=True)

    for root, dirs, files in os.walk(src):
        if any(p.startswith(".") for p in Path(root).parts):
            continue 

        # Compute relative path from the source root
        rel_path = os.path.relpath(root, src)
        dest_dir = os.path.join(dst, rel_path)

        os.makedirs(dest_dir, exist_ok=True)
  

        for file in files:
            if file.startswith("."):
                continue

            src_file = os.path.join(root, file)
            dest_file = os.path.join(dest_dir, file)
            shutil.copy2(src_file, dest_file)
            

# GLOBALS
logger = logging.getLogger("stsg.build")
TEMPLATE = Template(Path(SOURCE_DIRECTORY, "templates"))
ARTICLE_LAKE: Dict[str, ArticleOverview] = {}

def build():
    logger.info("building static page")  

    copy_static()
    tree = ArticleOverview(directory=Path(SOURCE_DIRECTORY, "pages"))
    
    print(ARTICLE_LAKE)
    
    tree.build()