"""Utility functions."""

import json
import math
import os.path
import re
import typing
from datetime import date
from itertools import islice
from typing import Any, cast

import flask
import user_agents
from num2words import num2words

metres_per_mile = 1609.344
feet_per_metre = 3.28084
feet_per_mile = 5280

T = typing.TypeVar("T")


def chunk(it: typing.Iterable[T], size: int) -> typing.Iterator[tuple[T, ...]]:
    """Split an iterable into chunks of the given size."""
    it = iter(it)
    return iter(lambda: tuple(islice(it, size)), ())


def flatten(top_list: list[list[T]]) -> list[T]:
    """Flatten a list."""
    return [item for sub_list in top_list for item in sub_list]


def drop_start(s: str, start: str) -> str:
    """Remove string prefix, otherwise throw an error."""
    assert s.startswith(start)
    return s[len(start) :]


def remove_start(s: str, start: str) -> str:
    """Remove a string prefix, if present."""
    return s[len(start) :] if s.startswith(start) else s


def normalize_url(url: str) -> str:
    """Standardize URLs to help in comparison."""
    for start in "http://", "https://", "www.":
        url = remove_start(url, start)
    return url.rstrip("/")


def contains_digit(s: str) -> bool:
    """Check if string contains a digit."""
    return any(c.isdigit() for c in s)


def cache_dir() -> str:
    """Get cache dir location."""
    d: str = flask.current_app.config["CACHE_DIR"]
    return d


def cache_filename(filename: str) -> str:
    """Get absolute path for cache file."""
    return os.path.join(cache_dir(), filename)


def load_from_cache(filename: str) -> Any:
    """Load JSON data from cache."""
    return json.load(open(cache_filename(filename)))


def get_radius(default: int = 1000) -> int | None:
    """Get radius request argument with default."""
    arg_radius = flask.request.args.get("radius")
    return int(arg_radius) if arg_radius and arg_radius.isdigit() else default


def get_int_arg(name: str) -> int | None:
    """Get an request arg and convert to integer."""
    v = flask.request.args.get(name)
    return int(v) if v and v.isdigit() else None


def calc_chunk_size(area_in_sq_km: float, size: int = 22) -> int:
    """Work out the size of a chunk."""
    side = math.sqrt(area_in_sq_km)
    return max(1, math.ceil(side / size))


def file_missing_or_empty(filename: str) -> bool:
    """Check if a file is missing or empty."""
    return os.path.exists(filename) or os.stat(filename).st_size == 0


def is_bot() -> bool:
    """Is the current request from a web robot."""
    ua = flask.request.headers.get("User-Agent")
    return bool(ua and user_agents.parse(ua).is_bot)


def log_location() -> str:
    """Get log location from Flask config."""
    return cast(str, flask.current_app.config["LOG_DIR"])


def capfirst(value: str) -> str:
    """Uppercase first letter of string, leave rest as is."""
    return value[0].upper() + value[1:] if value else value


def any_upper(value: str) -> bool:
    """Check if string contains any uppercase characters."""
    return any(c.isupper() for c in value)


def get_free_space(config: flask.config.Config) -> int:
    """Return the amount of available free space."""
    s = os.statvfs(config["FREE_SPACE_PATH"])
    return s.f_bsize * s.f_bavail


def metric_display_distance(units: str, dist: float) -> str | None:
    """Convert distance from metres to the specified metric units."""
    if units == "km_and_metres":
        units = "km" if dist > 500 else "metres"
    if units == "metres":
        return f"{dist:,.0f} m"
    if units == "km":
        return f"{dist / 1000:,.2f} km"

    return None


def display_distance(units: str, dist: float) -> str | None:
    """Convert distance from metres to the specified units."""
    if units in ("miles_and_feet", "miles_and_yards"):
        total_feet = dist * feet_per_metre
        miles = total_feet / feet_per_mile

        if miles > 0.5:
            return f"{miles:,.2f} miles"
        else:
            return {
                "miles_and_feet": f"{total_feet:,.0f} feet",
                "miles_and_yards": f"{total_feet / 3:,.0f} yards",
            }[units]

    if units == "miles_and_metres":
        miles = dist / metres_per_mile
        return f"{miles:,.2f} miles" if miles > 0.5 else f"{dist:,.0f} metres"

    return metric_display_distance(units, dist)


def is_in_range(address_range: str, address: str) -> bool:
    """Check if an address is within a range."""
    re_range = re.compile(r"\b(\d+) ?(?:to|-) ?(\d+)\b", re.I)
    re_number_list = re.compile(r"\b([\d, ]+) (?:and|&) (\d+)\b", re.I)
    re_number = re.compile(r"^(?:No\.?|Number)? ?(\d+)\b")

    m_number = re_number.match(address)
    if not m_number:
        return False

    m_range = re_range.search(address_range)
    if m_range:
        start, end = int(m_range.group(1)), int(m_range.group(2))
        if re_range.search(address):
            return False
        return start <= int(m_number.group(1)) <= end

    m_list = re_number_list.search(address_range)
    if m_list:
        numbers = {n.strip() for n in m_list.group(1).split(",")} | {m_list.group(2)}
        if re_number_list.search(address):
            return False
        return m_number.group(1) in numbers

    return False


class WikibaseTime(typing.TypedDict):
    """Wikibase Time dict."""

    precision: int
    time: str


def format_wikibase_time(v: WikibaseTime) -> str | None:
    """Format wikibase time value into human readable string."""
    t = v["time"]

    match v["precision"]:
        case 11:  # year, month and day
            return date.fromisoformat(t[1:11]).strftime("%-d %B %Y")
        case 10:  # year and month
            return date.fromisoformat(t[1:8] + "-01").strftime("%B %Y")
        case 9:  # year
            return t[1:5]
        case 8:  # decade
            return f"{t[1:4]}0s"
        case 7:  # century
            century = ((int(t[:5]) - 1) // 100) + 1
            ordinal_num: str = num2words(abs(century), to="ordinal_num")
            return f"{ordinal_num} {century}{' BC' if century < 0 else ''}"
        case _:  # not handled
            return None