from dataclasses import dataclass
from datetime import date

@dataclass(frozen=True)
class EventPeriod:
    """Represents an event with potentially disputed end dates."""
    name: str
    start: date
    end_primary: date
    end_alternative: date | None = None

    def duration_days(self, which: str = "primary") -> int:
        if which not in ("primary", "alternative"):
            raise ValueError("which must be 'primary' or 'alternative'")

        end = self.end_primary if which == "primary" else self.end_alternative
        if end is None:
            raise ValueError("No alternative end date provided")

        return (end - self.start).days

    def duration_weeks(self, which: str = "primary") -> tuple[int, int]:
        days = self.duration_days(which=which)
        weeks = days // 7
        remaining_days = days % 7
        return weeks, remaining_days

# Example events
# Event with both end dates
moon_landing = EventPeriod(
    name="Moon Landing",
    start=date(1969, 7, 16),
    end_primary=date(1969, 7, 24),      # landing completion (primary)
    end_alternative=date(1969, 7, 21),  # alternative milestone
)

# Event with missing alternative end date
some_trial = EventPeriod(
    name="Sample Trial",
    start=date(1945, 11, 20),
    end_primary=date(1946, 10, 1),
    end_alternative=None,
)

# Compute and print for first instance
p_weeks, p_rem = moon_landing.duration_weeks("primary")
a_weeks, a_rem = moon_landing.duration_weeks("alternative")

print(f"{moon_landing.name} primary duration: {p_weeks} weeks, {p_rem} days")
print(f"{moon_landing.name} alternative duration: {a_weeks} weeks, {a_rem} days")
print("Primary days:", moon_landing.duration_days("primary"))
print("Alternative days:", moon_landing.duration_days("alternative"))

# Compute and print for second instance
print("Second event primary days:", some_trial.duration_days("primary"))

# Attempt alternative and catch error
try:
    print("Second event alternative days:", some_trial.duration_days("alternative"))
except ValueError as e:
    print("Error:", str(e))

from dataclasses import dataclass
from datetime import date

@dataclass(frozen=True)
class UncertainRange:
    """Models a time range with potentially disputed start and end dates."""
    label: str
    start_primary: date
    start_alternative: date | None
    end_primary: date
    end_alternative: date | None

    def pick_start(self, which: str) -> date:
        if which not in ("primary", "alternative"):
            raise ValueError("which must be 'primary' or 'alternative'")
        if which == "primary":
            return self.start_primary
        if self.start_alternative is None:
            raise ValueError("No alternative start date provided")
        return self.start_alternative

    def pick_end(self, which: str) -> date:
        if which not in ("primary", "alternative"):
            raise ValueError("which must be 'primary' or 'alternative'")
        if which == "primary":
            return self.end_primary
        if self.end_alternative is None:
            raise ValueError("No alternative end date provided")
        return self.end_alternative

    def duration_days(self, which: str = "primary") -> int:
        start = self.pick_start(which)
        end = self.pick_end(which)
        days = (end - start).days
        if days < 0:
            raise ValueError("End is before start")
        return days

    def duration_breakdown(
        self,
        which: str = "primary",
        *,
        days_per_month: int = 30
    ) -> tuple[int, int, int]:
        days = self.duration_days(which=which)
        months = days // days_per_month
        remaining_after_months = days % days_per_month
        weeks = remaining_after_months // 7
        remaining_days = remaining_after_months % 7
        return months, weeks, remaining_days

# Fictional conflict with both alternative endpoints
conflict = UncertainRange(
    label="Fictional Conflict",
    start_primary=date(2000, 1, 10),
    start_alternative=date(2000, 1, 12),
    end_primary=date(2000, 3, 5),
    end_alternative=date(2000, 3, 1),
)

p_months, p_weeks, p_rem = conflict.duration_breakdown("primary")
a_months, a_weeks, a_rem = conflict.duration_breakdown("alternative")

print(f"{conflict.label} primary breakdown: {p_months} months, {p_weeks} weeks, {p_rem} days")
print(f"{conflict.label} alternative breakdown: {a_months} months, {a_weeks} weeks, {a_rem} days")
print("Primary days:", conflict.duration_days("primary"))
print("Alternative days:", conflict.duration_days("alternative"))

# Second range where alternative end is before alternative start
bad_range = UncertainRange(
    label="Bad Range",
    start_primary=date(2020, 1, 1),
    start_alternative=date(2020, 5, 10),
    end_primary=date(2020, 12, 31),
    end_alternative=date(2020, 5, 1),
)

try:
    bad_days = bad_range.duration_days("alternative")
    print("Bad range alternative days:", bad_days)
except ValueError as e:
    print("Error:", str(e))

from dataclasses import dataclass


@dataclass
class Faction:
    name: str
    military_deaths: int
    civilian_deaths: int

    @property
    def total_deaths(self) -> int:
        return self.military_deaths + self.civilian_deaths


def compare_scenarios(scenarios: list[tuple[str, Faction, Faction]]) -> None:
    for label, fed, uni in scenarios:
        scenario_total = fed.total_deaths + uni.total_deaths
        print(f"{label} scenario total deaths: {scenario_total:,}")
        print(f"  Federation total: {fed.total_deaths:,}")
        print(f"  Union total: {uni.total_deaths:,}")

        fed_military_share = fed.military_deaths / fed.total_deaths
        uni_military_share = uni.military_deaths / uni.total_deaths
        print(f"  Military share of own totals -> Federation: {fed_military_share:.2%}, Union: {uni_military_share:.2%}")


fed_low = Faction("Federation", military_deaths=12_000_000, civilian_deaths=8_000_000)
uni_low = Faction("Union", military_deaths=15_000_000, civilian_deaths=5_000_000)

fed_high = Faction("Federation", military_deaths=14_000_000, civilian_deaths=10_000_000)
uni_high = Faction("Union", military_deaths=18_000_000, civilian_deaths=7_000_000)

compare_scenarios([
    ("Low", fed_low, uni_low),
    ("High", fed_high, uni_high),
])

from dataclasses import dataclass


@dataclass
class Faction:
    name: str
    military_deaths: int
    civilian_deaths: int

    def validate_nonnegative(self) -> None:
        if self.military_deaths < 0 or self.civilian_deaths < 0:
            raise ValueError(f"{self.name} has negative death counts")

    @property
    def total_deaths(self) -> int:
        return self.military_deaths + self.civilian_deaths

    def military_share(self) -> float:
        total = self.total_deaths
        if total == 0:
            raise ZeroDivisionError(f"{self.name} has zero total deaths")
        return self.military_deaths / total


def check_consistency(
    scenarios: dict[str, tuple[Faction, Faction]],
    min_total: int,
    max_total: int,
) -> None:
    # Validate all factions first
    for label, (faction_a, faction_b) in scenarios.items():
        faction_a.validate_nonnegative()
        faction_b.validate_nonnegative()

    # Check A: range check per scenario
    for label in ["Low", "High"]:
        faction_fed, faction_uni = scenarios[label]
        scenario_total = faction_fed.total_deaths + faction_uni.total_deaths
        in_range = (min_total <= scenario_total <= max_total)
        suffix = "" if in_range else " OUT_OF_RANGE"
        print(f"{label} scenario total deaths: {scenario_total:,}{suffix}")

    # Check B: trend check for Federation military share
    low_fed = scenarios["Low"][0]
    high_fed = scenarios["High"][0]

    low_share = low_fed.military_share()
    high_share = high_fed.military_share()

    tol = 1e-9
    if abs(high_share - low_share) <= tol:
        print("MILITARY_SHARE_STABLE")
    elif high_share > low_share:
        print("MILITARY_SHARE_INCREASE")
    else:
        print("MILITARY_SHARE_DECREASE")


fed_low = Faction("Federation", military_deaths=10_000_000, civilian_deaths=10_000_000)
uni_low = Faction("Union", military_deaths=9_000_000, civilian_deaths=11_000_000)

fed_high = Faction("Federation", military_deaths=12_000_000, civilian_deaths=9_000_000)
uni_high = Faction("Union", military_deaths=10_000_000, civilian_deaths=9_000_000)

scenarios = {
    "Low": (fed_low, uni_low),
    "High": (fed_high, uni_high),
}

check_consistency(scenarios, min_total=35_000_000, max_total=45_000_000)

from dataclasses import dataclass
from typing import Dict, List

@dataclass(frozen=True)
class Book:
    title: str
    genre: str
    author: str
    publication_year: int

books: List[Book] = [
    Book(title="Dune", genre="Science Fiction", author="Frank Herbert", publication_year=1965),
    Book(title="Neuromancer", genre="Science Fiction", author="William Gibson", publication_year=1984),
    Book(title="The Left Hand of Darkness", genre="Science Fiction", author="Ursula K. Le Guin", publication_year=1969),
    Book(title="Pride and Prejudice", genre="Classic", author="Jane Austen", publication_year=1813),
    Book(title="Emma", genre="Classic", author="Jane Austen", publication_year=1815),
    Book(title="The Hobbit", genre="Fantasy", author="J. R. R. Tolkien", publication_year=1937),
]

by_genre: Dict[str, List[Book]] = {}
by_author: Dict[str, List[Book]] = {}

for b in books:
    by_genre.setdefault(b.genre, []).append(b)
    by_author.setdefault(b.author, []).append(b)


def render_index(index: Dict[str, List[Book]], title: str) -> str:
    lines = [title]
    for key in sorted(index.keys()):
        lines.append(f"- {key}:")
        for b in sorted(index[key], key=lambda x: x.title):
            lines.append(f"  * {b.title} ({b.publication_year})")
    return "\n".join(lines)


print(render_index(by_genre, "By genre"))
print()
print(render_index(by_author, "By author"))

print("\nQuery: Science Fiction + Frank Herbert")
query_genre = "Science Fiction"
query_author = "Frank Herbert"
for b in by_genre.get(query_genre, []):
    if b.author == query_author:
        print(f"- {b.title} ({b.publication_year})")

from dataclasses import dataclass
from typing import Dict, List, Set

@dataclass(frozen=True)
class Course:
    code: str
    title: str
    department: str
    level: str
    prerequisites: List[str]

courses: List[Course] = [
    Course(code="CS101", title="Intro to Programming", department="CS", level="Undergrad", prerequisites=[]),
    Course(code="CS102", title="Data Structures", department="CS", level="Undergrad", prerequisites=["CS101"]),
    Course(code="CS201", title="Algorithms", department="CS", level="Undergrad", prerequisites=["CS102"]),
    Course(code="CS301", title="Machine Learning", department="CS", level="Undergrad", prerequisites=["CS201"]),
    Course(code="MATH201", title="Discrete Mathematics", department="Math", level="Undergrad", prerequisites=[]),
    Course(code="CS210", title="Theory of Computation", department="CS", level="Undergrad", prerequisites=["MATH201"]),
    Course(code="CS401", title="Advanced Topics", department="CS", level="Graduate", prerequisites=["CS301", "CS210"]),
]

by_department: Dict[str, List[Course]] = {}
by_level: Dict[str, List[Course]] = {}

for c in courses:
    by_department.setdefault(c.department, []).append(c)
    by_level.setdefault(c.level, []).append(c)


def render_index(index: Dict[str, List[Course]], title: str) -> str:
    lines = [title]
    for key in sorted(index.keys()):
        lines.append(f"- {key}:")
        for c in sorted(index[key], key=lambda x: x.code):
            prereq = ",".join(sorted(c.prerequisites))
            lines.append(f"  * {c.code}: {c.title} [prereq: {prereq if prereq else "none"}]")
    return "\n".join(lines)


def build_graph(course_list: List[Course]) -> Dict[str, List[str]]:
    # Graph edges: course -> its prerequisites
    graph: Dict[str, List[str]] = {}
    for c in course_list:
        graph[c.code] = list(c.prerequisites)
    return graph


def detect_cycles(graph: Dict[str, List[str]]) -> None:
    # DFS with recursion stack
    visited: Set[str] = set()
    in_stack: Set[str] = set()

    def dfs(node: str) -> None:
        visited.add(node)
        in_stack.add(node)
        for nei in graph.get(node, []):
            # If neighbor is not in graph, treat it as a leaf node
            if nei not in visited:
                dfs(nei)
            elif nei in in_stack:
                raise ValueError(f"Cycle detected involving prerequisite code: {nei}")
        in_stack.remove(node)

    for node in list(graph.keys()):
        if node not in visited:
            dfs(node)


def find_courses(
    department: str,
    level: str,
    must_have_prereq: Set[str],
    by_department_index: Dict[str, List[Course]],
    by_level_index: Dict[str, List[Course]],
) -> List[Course]:
    # Pre-filter by department and level, then intersect by course code.
    dept_courses = by_department_index.get(department, [])
    level_courses = by_level_index.get(level, [])

    dept_codes = {c.code for c in dept_courses}
    level_codes = {c.code for c in level_courses}
    target_codes = dept_codes & level_codes

    result = []
    for c in courses:
        if c.code in target_codes:
            if set(c.prerequisites) & must_have_prereq:
                result.append(c)
    return sorted(result, key=lambda x: x.code)


# Cycle detection
graph = build_graph(courses)
detect_cycles(graph)
print("No prerequisite cycles found.")

print(render_index(by_department, "By department"))
print()
print(render_index(by_level, "By level"))

print("\nQuery: CS + Graduate + prereq in {CS301, MATH201}")
res = find_courses(
    department="CS",
    level="Graduate",
    must_have_prereq={"CS301", "MATH201"},
    by_department_index=by_department,
    by_level_index=by_level,
)
for c in res:
    print(f"- {c.code}: {c.title}")

from dataclasses import dataclass
from typing import Dict, List, Optional


@dataclass(frozen=True)
class Member:
    name: str
    region: str
    role: str


members: List[Member] = [
    Member(name="Asha", region="NA", role="Healer"),
    Member(name="Bran", region="NA", role="Tank"),
    Member(name="Celia", region="EU", role="DPS"),
    Member(name="Darius", region="EU", role="Support"),
    Member(name="Elena", region="APAC", role="DPS"),
    Member(name="Faris", region="APAC", role="Healer"),
]

# Index members by region
by_region: Dict[str, List[Member]] = {}
for m in members:
    by_region.setdefault(m.region, []).append(m)


def list_members(region: str) -> List[str]:
    return sorted([m.name for m in by_region.get(region, [])])


def find_member(name: str) -> Optional[Member]:
    target = name.strip().lower()
    for m in members:
        if m.name.lower() == target:
            return m
    return None


def compare_regions(regions: List[str]) -> None:
    for r in regions:
        print(f"{r} count:", len(by_region.get(r, [])))


print("NA members:")
for n in list_members("NA"):
    print("-", n)

print("\nEU members:")
for n in list_members("EU"):
    print("-", n)

print("\nAPAC members:")
for n in list_members("APAC"):
    print("-", n)

query = "  celia  "
found = find_member(query)
if found:
    print(f"\nLookup: {found.name} -> region={found.region}, role={found.role}")
else:
    print("\nLookup: not found")

print()
compare_regions(["NA", "APAC"])

from dataclasses import dataclass
from typing import Dict, List, Optional


@dataclass(frozen=True)
class Mission:
    title: str
    faction: str
    difficulty: str


missions: List[Mission] = [
    Mission(title="Aurora Drift", faction="Federation", difficulty="Low"),
    Mission(title="Black Nebula", faction="Federation", difficulty="High"),
    Mission(title="Crimson Relay", faction="Federation", difficulty="Medium"),
    Mission(title="Dawn Protocol", faction="Rebels", difficulty="Low"),
    Mission(title="Eclipse Run", faction="Rebels", difficulty="Medium"),
    Mission(title="Frost Signal", faction="Rebels", difficulty="High"),
    Mission(title="Aurora Drift", faction="Rebels", difficulty="Low"),
]

# Explicit difficulty ordering
difficulty_rank: Dict[str, int] = {"Low": 0, "Medium": 1, "High": 2}

# Two-level index: faction -> difficulty -> list of missions
missions_by_faction_and_difficulty: Dict[str, Dict[str, List[Mission]]] = {}
for m in missions:
    missions_by_faction_and_difficulty.setdefault(m.faction, {}).setdefault(m.difficulty, []).append(m)


def list_missions(faction: str, difficulty: str) -> List[str]:
    return sorted(
        [m.title for m in missions_by_faction_and_difficulty.get(faction, {}).get(difficulty, [])]
    )


def find_mission(title: str) -> Optional[Mission]:
    target = title.strip().lower()
    for m in missions:
        if m.title.lower() == target:
            return m
    return None


def best_mission(faction: str) -> Optional[Mission]:
    faction_map = missions_by_faction_and_difficulty.get(faction, {})
    if not faction_map:
        return None

    # Find the lowest rank difficulty that exists for this faction
    available_difficulties = list(faction_map.keys())
    lowest_rank = min(difficulty_rank[d] for d in available_difficulties if d in difficulty_rank)

    lowest_difficulty = None
    for d, r in difficulty_rank.items():
        if r == lowest_rank:
            lowest_difficulty = d
            break

    candidates = faction_map.get(lowest_difficulty, [])
    if not candidates:
        return None

    # Tie-break by alphabetically earliest title
    return sorted(candidates, key=lambda x: x.title)[0]


print("Federation Low missions:")
for t in list_missions("Federation", "Low"):
    print("-", t)

print("Rebels Medium missions:")
for t in list_missions("Rebels", "Medium"):
    print("-", t)

query = "  eclipse run  "
found = find_mission(query)
if found:
    print(f"\nLookup: {found.title} -> faction={found.faction}, difficulty={found.difficulty}")
else:
    print("\nLookup: not found")

best_fed = best_mission("Federation")
if best_fed:
    print(f"\nBest Federation mission: {best_fed.title} ({best_fed.difficulty})")
else:
    print("\nBest Federation mission: not found")

best_unknown = best_mission("Merchants")
if best_unknown:
    print(f"Best Merchants mission: {best_unknown.title} ({best_unknown.difficulty})")
else:
    print("Best Merchants mission: not found")