import os
import subprocess
import markdown
import yaml
from datetime import datetime

def filepath_or_string(s: str) -> str:
    '''Loads the contents of a string if it is a filepath, otherwise returns the string.'''
    if os.path.isfile(s):
        with open(s, 'r') as f:
            return f.read()
    else:
        return s
    

def load_markdown(md: str) -> tuple[dict, str]:
    '''Loads a Markdown file into a (metadata: dict, content: str) pair.'''
    
    # Load the file contents if a filepath is specified, and strip document delimiters ('---').
    md = filepath_or_string(md).strip().strip('---').strip()

    # If there is no `---` delimiter, then the article has no metadata.
    if '---' not in md.strip('---'):
        return {}, md
    
    # Split the metadata from the contents.
    [raw_metadata, raw_article] = md.split('---')
    
    # Use YAML to parse the metadata.
    metadata = yaml.safe_load(raw_metadata)

    # Convert the contents to a HTML string.
    content = markdown.markdown(raw_article)

    return metadata, content


def format_html_template(template: str, **kwargs) -> str:
    '''Interpolates variables specified as keyword arguments 
    into the given HTML template.'''

    # Load the template if a filepath is given.
    template = filepath_or_string(template)

    # Interpolate the kwargs into the HTML template.
    html = template.format(**kwargs)

    # Return the formatted HTML.
    return html


REPOS = [
    'ssh://gitea/jim/resume.git',
    'ssh://gitea/jim/dogma-jimfinium.git'
]
run = lambda cmd: subprocess.run(cmd.split(' '), stdout = subprocess.PIPE, stderr = subprocess.PIPE)
def update_git_repos(repos: list) -> None:
    '''Pulls updates to repos in the build directory, or clones them if they don't exist.'''
    for repo in repos:
        local_path = 'build/'+repo.split('/')[-1].strip('.git')
        print(local_path)
        if os.path.exists(f'{local_path}/.git'):
            run(f'git -C {local_path} pull origin')
        else: 
            run(f'git clone {repo} {local_path}')


def load_partials() -> dict:
    """Loads partial templates from the templates/partials directory."""
    partials = {}
    for filename in os.listdir('templates/partials'):
        with open(f'templates/partials/{filename}') as partial_file:
            partial_template = partial_file.read()
            
        partials[f'partials__{os.path.splitext(filename)[0]}'] = format_html_template(
            partial_template,
            current_year = datetime.now().year
        )
    return partials


def import_resume():

    # Use a sentinel value for the loop.
    max_date = '0000-00-00'

    # Loop through the folders in the resume repo to find the most recent one.
    for resume_folder in os.listdir('build/resume'):
        
        # Skip folders that are not in YYYY-MM-DD format.
        try:
            datetime.strptime(resume_folder,'%Y-%m-%d')
        except Exception:
            continue
        
        # Keep track of the most recent date.
        if resume_folder > max_date:
            max_date = resume_folder

    # Copy the resume into the /dist directory.            
    run(f'cp build/resume/{max_date}/shepich_resume.pdf dist/shepich_resume.pdf')


def format_blog_tags(tags: list[str], template = 'templates/components/blog_tag.html') -> list[str]:
    '''Generates HTML blog tag components from a list of tag names.'''
    return [
        format_html_template(template, tag_name = t) for t in tags
    ]

if __name__ == '__main__':
    pass