import re
from typing import List, Tuple

from obsidian.py_models import Training
from obsidian.mapper import obsidian_unique_exercies_mapping
from parsers.base_parser import BaseNotesParser


class ObsidianNotesParser(BaseNotesParser):
    """Parser for Obsidian Notes format training data."""
    
    def __init__(self):
        super().__init__("obsidian.md")
    
    def filter_training_data(self, training_data: str) -> str:
        """Filter Obsidian-specific training data format."""
        cleaned_text = re.sub(r"^\s*?\n", "", training_data, flags=re.MULTILINE)
        return cleaned_text
    
    def parse_training_header(self, training_data_line: str) -> Tuple[bool, str, str, str]:
        """Parse Obsidian Notes training header format."""
        pattern: str = r"#\s(?P<date>\d+.\d+.\d+)\s\((?P<trainer>.+)-(?P<year_counter>.+)\)"
        match = re.search(pattern, training_data_line)
        if match:
            date = match.group("date").strip()
            trainer = match.group("trainer").strip()
            year_count = match.group("year_counter").strip()
            return True, date, trainer, year_count
        return False, "", "", ""


def parse_training_data() -> List[Training]:
    """Parse Obsidian Notes training data."""
    parser = ObsidianNotesParser()
    return parser.parse_training_data()


def remap_unique_exercises(obsidian_trainings: List[Training]) -> List[Training]:
    """Remap exercise names using Obsidian-specific mapping."""
    for obsidian_training in obsidian_trainings:
        if not obsidian_training or not obsidian_training.exercises:
            continue
        for obsidian_exercise in obsidian_training.exercises:
            mapped_name = obsidian_unique_exercies_mapping.get(obsidian_exercise.name)
            if mapped_name is not None:
                obsidian_exercise.name = mapped_name
    return obsidian_trainings