from collections import defaultdict
from pathlib import Path
from typing import Optional

from ..entry import Entry, EntryDetector
from ..pipe.core import PipeParser, PipeRunner
from .resolve import PresetResolver, PresetResolverConfig

__all__ = ("PresetEntryDetector",)


class PresetEntryDetector(EntryDetector):
    _PIPE_PARSER = PipeParser()

    def __init__(self, preset_resolver_config: Optional[PresetResolverConfig] = None):
        self._pipeparser = PipeParser()
        self._preset_resolver_config = preset_resolver_config

    def detect_entry(self, basepath: Path) -> Optional["Entry"]:
        preset = PresetResolver(basepath, self._preset_resolver_config).resolve_preset()
        if preset.skip:
            return
        piperunner = PipeRunner(basepath)
        tasks = defaultdict(list)
        for preset_name, preset in preset.presets.items():
            if not piperunner.check_conditions(preset.conditions):
                continue
            for task_name, task_pack in preset.tasks.items():
                for task_item_name, task in task_pack.items():
                    if piperunner.check_conditions(task.conditions):
                        variables = {
                            "entry_path": basepath,
                        }
                        if task.variables:
                            variables.update(
                                {
                                    k: piperunner.resolve_value(v)
                                    for k, v in task.variables.items()
                                }
                            )
                        tasks[task_name] += [
                            command.format(**variables) for command in task.commands
                        ]
        if tasks:
            return Entry(tasks, basepath)