feat: implement timezone and country data handling in thctime module

thctime.py

@@ -0,0 +1,175 @@
+from datetime import datetime
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
+
+import pytz
+
+
+TZDB_CACHE: dict | None = None
+
+
+def get_tzdb_cache() -> dict | None:
+    return TZDB_CACHE
+
+
+def init_tzdb_cache() -> dict:
+    """Initialize a cached lookup structure for tzdb data."""
+    global TZDB_CACHE
+    if TZDB_CACHE is not None:
+        return TZDB_CACHE
+
+    timezones = load_timezones()
+    countries = load_countries()
+
+    tz_to_country_code: dict[str, str] = {}
+    tz_meta: dict[str, dict] = {}
+    for tz in timezones:
+        zone_name = tz.get("zone_name")
+        country_code = tz.get("country_code")
+        if not isinstance(zone_name, str) or not zone_name:
+            continue
+        if not isinstance(country_code, str) or not country_code:
+            continue
+
+        tz_to_country_code[zone_name] = country_code
+        region, city = split_tz_name(zone_name)
+        tz_meta[zone_name] = {
+            "zone_name": zone_name,
+            "country_code": country_code,
+            "region": region,
+            "city": city,
+        }
+
+    country_code_to_name: dict[str, str] = {}
+    for c in countries:
+        code = c.get("country_code")
+        name = c.get("country_name")
+        if code and name:
+            country_code_to_name[code] = str(name).strip().strip('"')
+
+    for zone_name, meta in tz_meta.items():
+        code = meta.get("country_code")
+        if isinstance(code, str):
+            meta["country_name"] = country_code_to_name.get(code)
+
+    tz_names: list[str] = []
+    for zone_name in tz_to_country_code.keys():
+        try:
+            ZoneInfo(zone_name)
+        except ZoneInfoNotFoundError:
+            continue
+        tz_names.append(zone_name)
+
+    TZDB_CACHE = {
+        "tz_to_country_code": tz_to_country_code,
+        "country_code_to_name": country_code_to_name,
+        "tz_names": tz_names,
+        "tz_meta": tz_meta,
+    }
+    return TZDB_CACHE
+
+
+def split_tz_name(zone_name: str) -> tuple[str, str]:
+    """Split an IANA timezone name into (region, city)."""
+    if "/" not in zone_name:
+        return zone_name, ""
+    region, rest = zone_name.split("/", 1)
+    return region, rest
+
+
+def load_timezones() -> list[dict]:
+    """Load timezones from csv file."""
+    with open("tzdb/TimeZoneDB.csv/time_zone.csv", "r", encoding="utf-8") as f:
+        lines = f.readlines()
+
+    timezones = []
+    for line in lines:
+        fields = line.strip().split(",")
+        if len(fields) >= 5:
+            timezones.append({
+                "zone_name": fields[0],
+                "country_code": fields[1],
+                "abbreviation": fields[2],
+                "time_start": fields[3],
+                "gmt_offset": int(fields[4]),
+                "dst": fields[5] == "1",
+            })
+    return timezones
+
+
+def load_countries() -> list[dict]:
+    """Load countries from csv file."""
+    with open("tzdb/TimeZoneDB.csv/country.csv", "r", encoding="utf-8") as f:
+        lines = f.readlines()
+
+    countries = []
+    for line in lines:
+        fields = line.strip().split(",")
+        if len(fields) >= 2:
+            countries.append({
+                "country_code": fields[0],
+                "country_name": fields[1],
+            })
+    return countries
+
+
+def get_tz_info(tz_name: str, timezones: list[dict]) -> dict | None:
+    """Get timezone info by name."""
+    return next((tz for tz in timezones if tz["zone_name"] == tz_name), None)
+
+
+def get_country_info(country_code: str, countries: list[dict]) -> dict | None:
+    """Get country info by country code."""
+    return next((c for c in countries if c["country_code"] == country_code), None)
+
+
+def where_is_it_420(
+    timezones: list[dict],
+    countries: list[dict],
+    tz_names: list[str] | None = None,
+    tz_to_country_code: dict[str, str] | None = None,
+    country_code_to_name: dict[str, str] | None = None,
+) -> list[str]:
+    """Get timezones where the current hour is 4 or 16."""
+    if tz_to_country_code is None:
+        tz_to_country_code = {}
+        for tz in timezones:
+            zone_name = tz.get("zone_name")
+            country_code = tz.get("country_code")
+            if isinstance(zone_name, str) and isinstance(country_code, str):
+                tz_to_country_code[zone_name] = country_code
+
+    if country_code_to_name is None:
+        country_code_to_name = {}
+        for c in countries:
+            code = c.get("country_code")
+            name = c.get("country_name")
+            if isinstance(code, str) and name is not None:
+                country_code_to_name[code] = str(name).strip().strip('"')
+
+    names_to_check = tz_names if tz_names is not None else pytz.all_timezones
+    results: list[str] = []
+    seen: set[str] = set()
+
+    for tz_name in names_to_check:
+        try:
+            tz_obj = pytz.timezone(tz_name)
+        except Exception:
+            continue
+
+        now = datetime.now(tz_obj)
+        if now.hour != 4 and now.hour != 16:
+            continue
+
+        country_code = tz_to_country_code.get(tz_name)
+        if not country_code:
+            continue
+        country_name = country_code_to_name.get(country_code)
+        if not country_name:
+            continue
+        if country_name in seen:
+            continue
+
+        seen.add(country_name)
+        results.append(country_name)
+
+    return results