import re
import json

from tqdm import tqdm
from loguru import logger

from pathlib import Path
from typing import Tuple, List


project_root = Path(__file__).parent.parent.parent

problem_tag = 'Problem'
solution_tag = 'Solution'


def clean_text(text: str) -> str:
    clean_texts = ["-SPB-", "SPB-", "-FIN-", "-POL-", "POL-", "EST-", "-DEN-", "DEN-", "NOR-", "-LAT-"]
    for clean_text in clean_texts:
        text = text.replace(clean_text, "")
    return text


def analyze(text: str) -> Tuple[List, int]:
    """
    Analyze the text and return the tags and problem number.
    Args:
        text (str): The markdown text to analyze.
    Returns:
        Tuple[List, int]: A tuple containing the tags and problem number.
    """
    problem_pattern = re.compile(r'(?:(?:\n|# )Problem\s+(\d+)(?:\.|\:)?|\n(\d+)\.|\n\#+\s+((?:A|C|G|N)\-\d+)\s+[A-Z]{3}\n)', re.IGNORECASE)
    solution_pattern = re.compile(r'(?:\n|# )Solution(?:\s+(\d+)\:?|\.|:|\n)', re.IGNORECASE)

    tags = []
    tags.extend([(x, problem_tag) for x in problem_pattern.finditer(text)])
    problem_num = len(tags)

    tags.extend([(x, solution_tag) for x in solution_pattern.finditer(text)])
    solution_num = len(tags) - problem_num

    tags.sort(key=lambda x: x[0].start())
    return tags, problem_num, solution_num


def segment(text: str, tags):
    starts = []
    ends = []

    for i in range(len(tags)):
        starts.append(tags[i][0].end())
        if i + 1 < len(tags):
            ends.append(tags[i + 1][0].start())
        else:
            ends.append(len(text))

    return [text[start:end].strip().strip('#').strip() for start, end in zip(starts, ends)]


def join(tags, segments, by_tag=False):
    problem, solution = '', ''
    problem_label, problem_match, solution_match = '', '', ''
    pairs = []

    if by_tag:
        seen = {}
        for tag, segment in zip(tags, segments):
            match = tag[0].group(0)
            if match in seen:
                problem, problem_match, problem_label = seen[match]
                pairs.append((problem, segment, problem_label, problem_match, match))
            else:
                seen[match] = (segment, match, tag[0].group(1) or tag[0].group(2) or tag[0].group(3))               
    else:
        for tag, segment in zip(tags, segments):
            if tag[1] == problem_tag:
                problem = segment
                problem_match = tag[0].group(0)
                problem_label = tag[0].group(1) or tag[0].group(2) or tag[0].group(3)
            else:
                solution = segment
                if solution.strip() == '':
                    continue

                solution_match = tag[0].group(0)
                pairs.append((problem, solution, problem_label, problem_match, solution_match))
            
    return pairs


def write_pairs(output_file: Path, pairs):
    year = re.search(r'(\d{2})', output_file.stem).group(1)
    year = f"20{year}" if int(year) >= 0 and int(year) <= 24 else f"19{year}"

    problem_type_mapping = {
        "A": "Algebra",
        "C": "Combinatorics",
        "G": "Geometry",
        "N": "Number Theory"
    }

    output_jsonl_text = ""
    for problem, solution, problem_label, problem_match, solution_match in pairs:
        output_jsonl_text += json.dumps(
            {
                'year': year,
                'tier': "T3",
                'problem_label': problem_label,
                'problem_type': problem_type_mapping.get(problem_label[0]),
                'exam': 'BalticWay',
                'problem': problem,
                'solution': solution,
                'metadata': {
                    'resource_path': output_file.relative_to(project_root).as_posix(),
                    'problem_match': problem_match,
                    'solution_match': solution_match
                }
            },
            ensure_ascii=False
        ) + '\n'

    output_file.write_text(output_jsonl_text, encoding="utf-8")


def main():
    compet_base_path = Path(__file__).resolve().parent.parent
    compet_md_path = compet_base_path / "md"
    seg_output_path = compet_base_path / "segmented"

    total_problem_count = 0
    total_solution_count = 0

    for bw_md in tqdm(list(compet_md_path.glob('**/*.md')), desc='Segmenting'):
        output_file = seg_output_path / bw_md.relative_to(compet_md_path).with_suffix('.jsonl')
        output_file.parent.mkdir(parents=True, exist_ok=True)

        text = '\n' + clean_text(bw_md.read_text(encoding="utf-8"))

        tags, problem_num, solution_num = analyze(text)

        segments = segment(text, tags)
        pairs = join(tags, segments, by_tag=solution_num == 0)     
        if pairs and problem_num > 0:
            write_pairs(output_file, pairs)

            total_problem_count += problem_num
            total_solution_count += len(pairs)
        else:
            logger.warning(f"No problem found in {bw_md}")
        
    logger.info(f"Total problem count: {total_problem_count}")
    logger.info(f"Total solution count: {total_solution_count}")


if __name__ == '__main__':
    main()