AI tushunadi, formula hisoblaydi: LLM'ni narx hisobiga aralashtirmaslik

Erkin matn ──► LLM (STRUKTURA AJRATADI) ──► {"name": "...", "qty": 20, ...}
                                                   │
                                                   ▼
                            Deterministik tarif xizmati (NARXNI HISOBLAYDI)
                                                   │
                                                   ▼
                                          Bir xil kirish = bir xil narx

bot/
├── ai/
│   ├── __init__.py
│   ├── schemas.py       ← LLM chiqishi sxemasi (hozir shu yerdamiz)
│   └── extractor.py     ← LLM chaqiruvi
├── tariff/
│   ├── __init__.py
│   └── calculator.py    ← deterministik hisob
└── handlers/
    └── ai_calc.py       ← bot handler: ikkalasini bog'laydi

# bot/ai/schemas.py
from pydantic import BaseModel, Field


class CargoItem(BaseModel):
    """LLM'dan qaytishi SHART bo'lgan struktura — boshqa hech narsa."""

    name: str = Field(description="Tovar nomi, qisqa")
    quantity: int = Field(gt=0, description="Nechta birlik (quti, dona...)")
    unit_weight_kg: float | None = Field(
        default=None, ge=0, description="Bir birlik og'irligi, kg. Aytilmagan bo'lsa null"
    )
    total_volume_m3: float | None = Field(
        default=None, ge=0, description="Umumiy hajm, m³. Aytilmagan bo'lsa null"
    )


class ExtractionResult(BaseModel):
    items: list[CargoItem]
    # LLM topa olmagan narsani TAXMIN QILMASIN — ochiq aytsin:
    missing: list[str] = Field(
        default_factory=list,
        description="Hisob uchun yetishmayotgan ma'lumotlar ro'yxati (o'zbekcha)",
    )

# bot/ai/extractor.py
from openai import OpenAI

from .schemas import ExtractionResult

client = OpenAI()  # OPENAI_API_KEY muhitdan olinadi

SYSTEM = """Sen logistika botining ajratuvchisisan. Foydalanuvchi yuk tavsifini
o'zbek, rus yoki aralash tilda yozadi. Vazifang — FAQAT strukturani ajratish.
Qoidalar:
- hech narsani hisoblama, narx aytma;
- aytilmagan qiymatni taxmin qilma — null qoldir va missing'ga yoz;
- birliklarni normalizatsiya qil: tonna→kg, litr→m³ emas (hajm faqat m³/kub)."""


def extract_cargo(text: str) -> ExtractionResult:
    # parse() javobni to'g'ridan-to'g'ri Pydantic sxemaga majburlaydi:
    # model sxemadan tashqari JSON qaytara olmaydi
    response = client.chat.completions.parse(
        model="gpt-4o-mini",  # ajratish uchun kichik model yetarli va arzon
        messages=[
            {"role": "system", "content": SYSTEM},
            {"role": "user", "content": text},
        ],
        response_format=ExtractionResult,
        temperature=0,  # ajratish ijod emas — barqarorlik kerak
    )
    return response.choices[0].message.parsed

# bot/tariff/calculator.py
from dataclasses import dataclass

from bot.ai.schemas import CargoItem


@dataclass(frozen=True)
class Tariff:
    """Zichlik oralig'iga bitta narx: [min_density, max_density) kg/m³."""

    min_density: float
    max_density: float
    price_per_kg: float | None  # zich yuk uchun
    price_per_m3: float | None  # hajmli yuk uchun


# Real tizimda bu ro'yxat bazadan/Excel'dan keladi (Humo'da menejerlar
# o'zi yangilaydi) — bu yerda soddalik uchun konstanta
TARIFFS = [
    Tariff(0, 100, None, 180.0),  # juda hajmli: kub bilan
    Tariff(100, 250, 1.10, None),  # o'rtacha: kilo bilan
    Tariff(250, float("inf"), 0.85, None),  # zich: kilo bilan, arzonroq
]


class CalculationError(Exception):
    pass


def calculate(items: list[CargoItem]) -> dict:
    total_kg = sum((i.unit_weight_kg or 0) * i.quantity for i in items)
    total_m3 = sum(i.total_volume_m3 or 0 for i in items)
    if total_kg <= 0 or total_m3 <= 0:
        # bu holat handler'gacha yetmasligi kerak (missing tekshiruvi bor),
        # lekin sof funksiya o'z shartlarini O'ZI himoya qiladi
        raise CalculationError("og'irlik va hajm musbat bo'lishi shart")

    density = total_kg / total_m3
    tariff = next(t for t in TARIFFS if t.min_density <= density < t.max_density)

    if tariff.price_per_kg is not None:
        price = round(total_kg * tariff.price_per_kg, 2)
        basis = f"{total_kg:.0f} kg × ${tariff.price_per_kg}"
    else:
        price = round(total_m3 * tariff.price_per_m3, 2)
        basis = f"{total_m3:.2f} m³ × ${tariff.price_per_m3}"

    return {"price_usd": price, "density": round(density, 1), "basis": basis}

# bot/handlers/ai_calc.py
from aiogram import types

from bot.ai.extractor import extract_cargo
from bot.tariff.calculator import CalculationError, calculate


async def handle_ai_calc(message: types.Message):
    try:
        extraction = extract_cargo(message.text)
    except Exception:
        # AI ishlamasa — mijozni klassik formaga yo'naltiramiz.
        # Bot AI'siz ham TO'LIQ ishlashi shart (graceful degradation)
        await message.answer(
            "Hozir avtomatik tahlil ishlamayapti. /calc bilan forma orqali hisoblang."
        )
        return

    if extraction.missing:
        # taxmin qilmaymiz — so'raymiz. AI'ning "bilmadim"i — xato emas, xususiyat
        missing = "\n".join(f"— {m}" for m in extraction.missing)
        await message.answer(f"Hisob uchun quyidagilar yetishmayapti:\n{missing}")
        return

    try:
        result = calculate(extraction.items)
    except CalculationError as exc:
        await message.answer(f"Hisoblab bo'lmadi: {exc}")
        return

    names = ", ".join(i.name for i in extraction.items)
    await message.answer(
        f"📦 {names}\n"
        f"Zichlik: {result['density']} kg/m³\n"
        f"Hisob: {result['basis']}\n"
        f"<b>Narx: ${result['price_usd']}</b>",
        parse_mode="HTML",
    )

# tests/test_calculator.py
import pytest

from bot.ai.schemas import CargoItem
from bot.tariff.calculator import CalculationError, calculate


def item(qty=20, kg=3.0, m3=0.5):
    return CargoItem(name="aksessuar", quantity=qty, unit_weight_kg=kg, total_volume_m3=m3)


def test_dense_cargo_priced_per_kg():
    # 60 kg / 0.5 m³ = 120 kg/m³ → o'rta tarif, kilo bilan
    result = calculate([item()])
    assert result == {"price_usd": 66.0, "density": 120.0, "basis": "60 kg × $1.10"}


def test_bulky_cargo_priced_per_m3():
    # 10 kg / 0.5 m³ = 20 kg/m³ → hajmli tarif, kub bilan
    result = calculate([item(qty=10, kg=1.0)])
    assert result["basis"] == "0.50 m³ × $180.0"


def test_zero_weight_rejected():
    with pytest.raises(CalculationError):
        calculate([item(kg=0.0, m3=0.0)])