from collections import defaultdict
import pytest

from singularity.code import g, data, prerequisite
from singularity.code.dirs import create_directories


def setup_module():
    create_directories(True)


@pytest.fixture
def techs():
    data.load_techs()
    return g.techs.copy()


@pytest.fixture
def locations():
    data.load_regions()
    data.load_locations()
    return g.locations.copy()


@pytest.fixture
def base_types():
    data.load_bases()
    return g.base_type.copy()


@pytest.fixture
def items():
    data.load_item_types()
    data.load_items()
    return g.items.copy()


@pytest.fixture
def tasks():
    data.load_tasks()
    return g.tasks.copy()


def test_valid_prerequisites_techs(techs):
    prerequisites_references_valid_techs(techs, g.techs.values(), "Tech")


def test_valid_prerequisites_locations(techs, locations):
    prerequisites_references_valid_techs(techs, locations.values(), "Location")


def test_valid_prerequisites_bases(techs, base_types):
    prerequisites_references_valid_techs(techs, base_types.values(), "Base(Class)")


def test_valid_prerequisites_items(techs, items):
    prerequisites_references_valid_techs(techs, items.values(), "Item(Class)")


def test_valid_prerequisites_tasks(techs, tasks):
    prerequisites_references_valid_techs(techs, tasks.values(), "Tasks")


def prerequisites_references_valid_techs(
    techs, prerequisites_list, prerequisite_typename
):
    for prereq in prerequisites_list:
        if isinstance(prereq, prerequisite.Prerequisite):
            conjunction = prereq.prerequisites_in_cnf_format()
        else:
            spec = prereq.spec if hasattr(prereq, "spec") else prereq.type
            conjunction = spec.prerequisites_in_cnf_format()

        if conjunction is None:
            # deliberately marked impossible
            continue
        for disjunction in conjunction:
            print(
                (
                    "%s %s -> At least one of: %s"
                    % (prerequisite_typename, prereq.id, str(sorted(disjunction)))
                )
            )
            for tech_dep_id in disjunction:
                assert "|" not in tech_dep_id, (
                    '%s "%s" references unknown dependency tech "%s" ('
                    "did you use pre instead of pre_list?)"
                    % (prerequisite_typename, prereq.id, tech_dep_id)
                )
                assert (
                    tech_dep_id in techs
                ), '%s "%s" references unknown dependency tech "%s"' % (
                    prerequisite_typename,
                    prereq.id,
                    tech_dep_id,
                )
            for keyword in ("impossible", "OR"):
                assert (
                    keyword not in disjunction
                ), 'The keyword "%s" must be the first in a pre_list (%s: "%s")' % (
                    prerequisite_typename,
                    keyword,
                    prereq.id,
                )


def test_acyclic_dependencies(techs):
    waiting_for = defaultdict(list)
    impossible_techs = set()
    researched_techs = set()
    researchable_techs = []

    for tech in techs.values():
        conjunction = tech.prerequisites_in_cnf_format()
        if conjunction is None:
            # deliberately marked impossible
            impossible_techs.add(tech.id)
            continue
        if not conjunction:
            researchable_techs.append(tech.id)
            continue
        for disjunction in conjunction:
            for tech_dep_id in disjunction:
                waiting_for[tech_dep_id].append(tech)

    while researchable_techs:
        new_tech = researchable_techs.pop()
        if new_tech in researched_techs:
            continue
        print(("Researchable %s" % new_tech))
        researched_techs.add(new_tech)
        techs_waiting = waiting_for[new_tech]
        del waiting_for[new_tech]
        for t in techs_waiting:
            if t.id in researched_techs:
                continue
            conjunction = t.prerequisites_in_cnf_format()
            researchable = True
            for disjunction in conjunction:
                if not all(x in researched_techs for x in disjunction):
                    researchable = False
                    break
            if researchable:
                researchable_techs.append(t.id)

    for x, y in waiting_for.items():
        print(
            (
                "%s cannot be researched and is blocking %s"
                % (x, str(sorted(t.id for t in y)))
            )
        )

    assert not waiting_for
