from __future__ import annotations

import re
from typing import Any


AMOUNT_PATTERN = r"(?P<amount>(?:K|ZMW|kwacha)?\s*\d[\d,]*(?:\.\d+)?)"
CONNECTOR_PATTERN = r"[^\dK\.\n!?]{0,20}"
BUSINESS_PATTERNS = {
    "grocery shop": [r"grocery shop", r"small shop", r"shop owner", r"mini mart", r"market shop"],
    "salon": [r"salon", r"barbershop", r"barber shop", r"barber"],
    "farmer": [r"farmer", r"farm", r"agri", r"produce seller"],
    "freelancer": [r"freelancer", r"consultant", r"designer", r"developer", r"writer"],
}


def _parse_amount(raw_value: str | None) -> float:
    if not raw_value:
        return 0.0
    cleaned = re.sub(r"[^0-9.]", "", raw_value.replace(",", ""))
    return float(cleaned) if cleaned else 0.0


def _extract_first_amount(text: str, patterns: list[str]) -> float:
    for pattern in patterns:
        match = re.search(pattern, text, flags=re.IGNORECASE)
        if match:
            return _parse_amount(match.group("amount"))
    return 0.0


def _detect_business_type(text: str) -> str | None:
    for business_type, patterns in BUSINESS_PATTERNS.items():
        if any(re.search(pattern, text, flags=re.IGNORECASE) for pattern in patterns):
            return business_type
    return None


def _detect_location(text: str) -> str | None:
    match = re.search(r"\b(?:in|at|from)\s+([A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)", text)
    if match:
        return match.group(1).strip()
    return None


def _extract_category_amounts(text: str) -> dict[str, float]:
    category_patterns = {
        "stock": [
            rf"{AMOUNT_PATTERN}\s+(?:on|for)\s+(?:stock|inventory|restocking|products|supplies|inputs)",
            rf"(?:stock|inventory|restocking|products|supplies|inputs)(?:{CONNECTOR_PATTERN}){AMOUNT_PATTERN}",
        ],
        "rent": [
            rf"{AMOUNT_PATTERN}\s+(?:on|for)\s+rent",
            rf"rent(?:{CONNECTOR_PATTERN}){AMOUNT_PATTERN}",
        ],
        "transport": [
            rf"{AMOUNT_PATTERN}\s+(?:on|for)\s+transport",
            rf"transport(?:ation)?(?:{CONNECTOR_PATTERN}){AMOUNT_PATTERN}",
        ],
        "other_expenses": [
            rf"{AMOUNT_PATTERN}\s+(?:on|for)\s+other expenses",
            rf"other expenses(?:{CONNECTOR_PATTERN}){AMOUNT_PATTERN}",
        ],
        "sales": [
            rf"(?:made|earned|generated|received)(?:{CONNECTOR_PATTERN}){AMOUNT_PATTERN}(?:\s+(?:in|from)\s+sales)?",
            rf"{AMOUNT_PATTERN}\s+(?:in|from)\s+sales",
            rf"(?:sales|revenue|income)(?:{CONNECTOR_PATTERN}){AMOUNT_PATTERN}",
        ],
        "debt": [
            rf"(?:owe|owing|debt|supplier debt)(?:{CONNECTOR_PATTERN}){AMOUNT_PATTERN}",
            rf"{AMOUNT_PATTERN}\s+(?:to|in)\s+(?:my\s+)?supplier",
        ],
        "loan_amount": [
            rf"{AMOUNT_PATTERN}\s+loan",
            rf"(?:loan|borrow)(?:{CONNECTOR_PATTERN}){AMOUNT_PATTERN}",
        ],
    }

    return {
        category: _extract_first_amount(text, patterns)
        for category, patterns in category_patterns.items()
    }


def _extract_general_expenses(text: str) -> float:
    patterns = [
        rf"(?:total expenses|overall expenses|expenses were)(?:{CONNECTOR_PATTERN}){AMOUNT_PATTERN}",
        rf"(?:spent)(?:{CONNECTOR_PATTERN}){AMOUNT_PATTERN}",
    ]
    return _extract_first_amount(text, patterns)


def parse_business_input(text: str) -> dict[str, Any]:
    lowered = text.lower()
    extracted = _extract_category_amounts(text)

    expenses_breakdown = {
        "stock": extracted.get("stock", 0.0),
        "rent": extracted.get("rent", 0.0),
        "transport": extracted.get("transport", 0.0),
        "other_expenses": extracted.get("other_expenses", 0.0),
    }
    detailed_expenses = round(sum(expenses_breakdown.values()), 2)
    total_expenses = detailed_expenses or _extract_general_expenses(text)

    revenue = extracted.get("sales", 0.0)
    if revenue == 0:
        revenue = _extract_first_amount(
            text,
            [
                rf"(?:made|earned|revenue|income)(?:{CONNECTOR_PATTERN}){AMOUNT_PATTERN}",
                rf"{AMOUNT_PATTERN}\s+(?:in|from)\s+(?:sales|revenue|income)",
            ],
        )

    debt = extracted.get("debt", 0.0)
    loan_amount = extracted.get("loan_amount", 0.0)

    return {
        "raw_text": text,
        "revenue": round(revenue, 2),
        "expenses": round(total_expenses, 2),
        "expenses_breakdown": expenses_breakdown,
        "debt": round(debt, 2),
        "loan_amount": round(loan_amount, 2),
        "business_type": _detect_business_type(lowered),
        "location": _detect_location(text),
        "categories_detected": [name for name, value in expenses_breakdown.items() if value > 0],
    }