"""Анализ надёжности оборудования по данным портала.

Методика — «Надёжность и безопасность» (ИАТЭ, 2005) и ГОСТ 27.002, кратко:
- отказы считаются пуассоновским потоком (ординарный, без последействия), на участке нормальной эксплуатации λ ≈ const;
- λ = n / T, наработка на отказ θ = T / n, где T — наработка за период (моточасы по счётчику), n — число отказов;
- консервативная оценка по мало- или безотказному опыту (раздел 3.1): верхняя граница λ при доверии Pα —
  χ²(Pα; 2n+2) / (2T); при n = 0 это −ln(1−Pα)/T (2,30/T при 0,9), «средневероятная» — при Pα = 0,5;
- среднее время восстановления Tв и коэффициент готовности Kг = θ / (θ + Tв);
- прогноз числа отказов на следующий период по Пуассону: μ = λ·t, P(≥1) = 1 − e^(−μ);
- модель «параметр — граница работоспособности» (раздел 3.2): линейный дрейф числового пункта чек-листа к границе
  нормы и частота выходов за неё (ν).
Абсолютные значения приблизительны (мало данных, допущения в сторону запаса); главная польза — сравнение машин между собой.
"""
import csv
import io
import math
from collections import Counter, defaultdict
from datetime import datetime, timedelta

from sqlalchemy import select
from sqlalchemy.orm import Session

from . import config
from .models import Department, Equipment, Incident, IncidentUnit, Location, MeterReading, Order, OrderItem, ServiceEvent, ServiceUnit

CAUSE_RU = {"wear": "Износ и старение", "operation": "Нарушение условий эксплуатации, ошибка персонала",
            "external": "Внешние воздействия (температура, влага, пыль, вибрация)", "power": "Электропитание или смежные системы",
            "defect": "Дефект изготовления, монтажа или прошлого ремонта", "secondary": "Вследствие отказа другого узла",
            "unknown": "Не установлена"}
ACTION_RU = {"repair": "Ремонт", "replace": "Замена узла", "adjust": "Регулировка или наладка", "restart": "Перезапуск без ремонта (сбой)"}
NATURE_RU = {"sudden": "Внезапный", "gradual": "Постепенный"}
PRECURSOR_RU = {"inspection": "Замечено на обходе или в чек-листе", "fault_report": "Было сообщение о неисправности", "none": "Признаков не было"}
SERVICE_KIND_RU = {"initial": "начальное состояние", "order": "плановое по наряду", "reset": "вне наряда", "incident": "замена при отказе"}


# ---------- статистика ----------
def poisson_tail(k: int, x: float) -> float:
    """P(χ²(2k) > x) = Σ_{i<k} e^(−x/2)(x/2)^i/i! — для чётного числа степеней свободы считается точно."""
    m = x / 2
    term, s = math.exp(-m), 0.0
    for i in range(k):
        if i:
            term *= m / i
        s += term
    return s


def chi2_quantile_even(p: float, k: int) -> float:
    """Квантиль χ² с 2k степенями свободы уровня p (P(χ² ≤ x) = p), бисекцией."""
    lo, hi = 0.0, max(10.0, 4.0 * k + 40)
    for _ in range(200):
        mid = (lo + hi) / 2
        if 1 - poisson_tail(k, mid) < p:
            lo = mid
        else:
            hi = mid
    return (lo + hi) / 2


def lambda_bound(n: int, t: float, p: float) -> float | None:
    """Оценка интенсивности отказов при доверии p по n отказам за наработку t (раздел 3.1 методички)."""
    if t <= 0:
        return None
    return chi2_quantile_even(p, n + 1) / 2 / t


# ---------- наработка ----------
def hours_between(readings: list[tuple[datetime, float]], start: datetime, end: datetime) -> float | None:
    """Наработка по счётчику за [start, end]: сумма приростов (коррекции счётчика вниз не уменьшают сумму),
    значения на границах — линейная интерполяция между показаниями. None — показаний недостаточно."""
    if len(readings) < 2:
        return None
    pts = sorted(readings)

    def at(t: datetime) -> float:
        if t <= pts[0][0]:
            return pts[0][1]
        if t >= pts[-1][0]:
            return pts[-1][1]
        for (t1, h1), (t2, h2) in zip(pts, pts[1:]):
            if t1 <= t <= t2:
                if t2 == t1 or h2 < h1:
                    return h1
                return h1 + (h2 - h1) * (t - t1).total_seconds() / (t2 - t1).total_seconds()
        return pts[-1][1]

    inner = [(start, at(start))] + [(t, h) for t, h in pts if start < t < end] + [(end, at(end))]
    total = sum(max(0.0, b[1] - a[1]) for a, b in zip(inner, inner[1:]))
    covered = min(end, pts[-1][0]) > max(start, pts[0][0])
    return total if covered else None


def failure_at(i: Incident) -> datetime:
    return i.escalated_at or i.occurred_at


def _r(v, n=1):
    return None if v is None else round(v, n)


# ---------- сводный отчёт ----------
def analyze(db: Session, start: datetime, end: datetime, equipment_ids: set[int] | None, conf: float = 0.9,
            horizon_days: int = 30) -> dict:
    eqs = [e for e in db.scalars(select(Equipment).where(Equipment.is_active.is_(True)).order_by(Equipment.name))
           if equipment_ids is None or e.id in equipment_ids]
    ids = [e.id for e in eqs]
    locs = dict(db.execute(select(Location.id, Location.name)).all())
    deps = dict(db.execute(select(Department.id, Department.name)).all())
    readings = defaultdict(list)
    for eid, at, h in db.execute(select(MeterReading.equipment_id, MeterReading.at, MeterReading.hours).where(MeterReading.equipment_id.in_(ids))):
        readings[eid].append((at, h))
    incs = [i for i in db.scalars(select(Incident).where(Incident.equipment_id.in_(ids))).all()]
    units = {u.id: u for u in db.scalars(select(ServiceUnit).where(ServiceUnit.equipment_id.in_(ids)))}
    period_h = (end - start).total_seconds() / 3600
    days = max(1.0, period_h / 24)
    rows, tot = [], Counter()
    causes, natures, actions, precursors, cause_units, months = Counter(), Counter(), Counter(), Counter(), Counter(), Counter()
    tv_all = []
    for e in eqs:
        mine = [i for i in incs if i.equipment_id == e.id]
        fails = [i for i in mine if i.kind == "incident" and start <= failure_at(i) < end]
        faults = [i for i in mine if start <= i.occurred_at < end and (i.kind == "fault" or i.escalated_at)]
        escalated = [i for i in fails if i.escalated_at]
        oh = hours_between(readings.get(e.id, []), start, end)
        basis = "meter"
        if oh is None:  # нет счётчика — календарное время (консервативно: машина работала круглосуточно)
            oh, basis = period_h, "calendar"
        n = len(fails)
        lam = n / oh if oh > 0 and n else None
        lam_up = lambda_bound(n, oh, conf)
        lam_mid = lambda_bound(n, oh, 0.5)
        theta = oh / n if n and oh > 0 else None
        tv = [(i.restored_at - failure_at(i)).total_seconds() / 3600 for i in fails if i.restored_at and i.restored_at >= failure_at(i)]
        repair = [(i.restored_at - i.repair_started_at).total_seconds() / 3600 for i in fails
                  if i.restored_at and i.repair_started_at and i.restored_at >= i.repair_started_at]
        wait = [i.parts_wait_hours for i in fails if i.parts_wait_hours]
        tv_mean = sum(tv) / len(tv) if tv else None
        tv_all += tv
        down = sum(tv)
        open_fail = next((i for i in mine if i.kind == "incident" and i.status == "open"), None)
        if open_fail:  # текущий простой учитываем до конца периода
            down += max(0.0, (min(end, config.now()) - max(start, failure_at(open_fail))).total_seconds() / 3600)
        kg = theta / (theta + tv_mean) if theta and tv_mean is not None else None
        # прогноз: ожидаемая наработка за горизонт по средней интенсивности использования
        rate = oh / days
        lam_fc = lam if lam else lam_mid
        mu = (lam_fc or 0) * rate * horizon_days
        rows.append({
            "equipment_id": e.id, "equipment": e.name, "inventory_no": e.inventory_no, "location": locs.get(e.location_id, ""),
            "department": deps.get(e.department_id, ""), "is_crane": bool(e.is_crane), "basis": basis,
            "hours": _r(oh), "failures": n, "faults": len(faults), "escalated": len(escalated),
            "lambda": lam, "lambda_upper": lam_up, "theta": _r(theta), "theta_lower": _r(1 / lam_up if lam_up else None),
            "theta_median": _r(1 / lam_mid if lam_mid else None),
            "mttr": _r(tv_mean, 2), "repair_mean": _r(sum(repair) / len(repair), 2) if repair else None,
            "wait_mean": _r(sum(wait) / len(wait), 2) if wait else None, "downtime": _r(down, 2),
            "availability": _r(kg, 4), "availability_period": _r(max(0.0, 1 - down / period_h), 4) if period_h else None,
            "forecast_mu": _r(mu, 3), "forecast_p": _r(1 - math.exp(-mu), 3) if mu else 0.0,
        })
        tot["hours"] += oh
        tot["failures"] += n
        tot["faults"] += len(faults)
        tot["escalated"] += len(escalated)
        tot["downtime"] += down
        for i in fails:
            causes[i.cause or "—"] += 1
            natures[i.nature or "—"] += 1
            actions[i.action or "—"] += 1
            precursors[i.precursor or "—"] += 1
            cu = units.get(i.cause_unit_id)
            cause_units[(e.name + " / " + cu.name) if cu else (e.name + " / " + (i.cause_unit_other or "узел не указан"))] += 1
            months[failure_at(i).strftime("%Y-%m")] += 1
    # по парку целиком
    n, t = tot["failures"], tot["hours"]
    lu = lambda_bound(n, t, conf)
    fleet = {"machines": len(rows), "hours": _r(t), "failures": n, "faults": tot["faults"], "escalated": tot["escalated"],
             "theta": _r(t / n) if n else None, "theta_lower": _r(1 / lu) if lu else None,
             "mttr": _r(sum(tv_all) / len(tv_all), 2) if tv_all else None, "downtime": _r(tot["downtime"], 2),
             "without_failures": sum(1 for r in rows if not r["failures"])}

    def dist(c: Counter, names: dict) -> list[dict]:
        total = sum(c.values()) or 1
        return [{"key": k, "name": names.get(k, "не указано" if k == "—" else k), "n": v, "pct": round(100 * v / total)} for k, v in c.most_common()]

    rows.sort(key=lambda r: (-(r["failures"]), -(r["faults"]), r["theta_lower"] or 0))
    return {"from": config.iso(start), "to": config.iso(end), "confidence": conf, "horizon_days": horizon_days,
            "fleet": fleet, "rows": rows,
            "causes": dist(causes, CAUSE_RU), "natures": dist(natures, NATURE_RU), "actions": dist(actions, ACTION_RU),
            "precursors": dist(precursors, PRECURSOR_RU),
            "cause_units": [{"name": k, "n": v} for k, v in cause_units.most_common(15)],
            "months": [{"month": k, "n": months[k]} for k in sorted(months)]}


# ---------- «параметр — граница»: дрейф числовых пунктов чек-листов ----------
def drift(db: Session, equipment_ids: set[int] | None, days: int = 180, horizon: int = 90) -> list[dict]:
    """Числовые пункты нарядов с нормой: тренд значения к границе и частота выходов за неё (ν).
    Прогноз даты выхода за границу — линейная регрессия по времени (линейный дрейф параметра)."""
    since = config.now() - timedelta(days=days)
    q = (select(OrderItem, Order.equipment_id).join(Order, Order.id == OrderItem.order_id)
         .where(OrderItem.answer_type == "number", OrderItem.answered_at.is_not(None), OrderItem.answered_at >= since,
                Order.equipment_id.is_not(None)))
    groups = defaultdict(list)
    for it, eid in db.execute(q):
        if equipment_ids is not None and eid not in equipment_ids:
            continue
        if it.min_value is None and it.max_value is None:
            continue
        try:
            v = float(str(it.value).replace(",", "."))
        except (TypeError, ValueError):
            continue
        groups[(eid, it.text.strip(), it.min_value, it.max_value, it.unit)].append((it.answered_at, v, bool(it.out_of_range)))
    names = dict(db.execute(select(Equipment.id, Equipment.name)).all())
    now = config.now()
    out = []
    for (eid, text, lo, hi, unit), pts in groups.items():
        if len(pts) < 3:
            continue
        pts.sort()
        t0 = pts[0][0]
        xs = [(t - t0).total_seconds() / 86400 for t, _, _ in pts]
        ys = [v for _, v, _ in pts]
        n = len(xs)
        mx, my = sum(xs) / n, sum(ys) / n
        sxx = sum((x - mx) ** 2 for x in xs)
        slope = sum((x - mx) * (y - my) for x, y in zip(xs, ys)) / sxx if sxx else 0.0
        x_now = (now - t0).total_seconds() / 86400
        fit_now = my + slope * (x_now - mx)
        days_to = None
        bound = None
        if slope > 0 and hi is not None:
            days_to, bound = (hi - fit_now) / slope, "max"
        elif slope < 0 and lo is not None:
            days_to, bound = (lo - fit_now) / slope, "min"
        out_n = sum(1 for _, _, o in pts if o)
        span = max(1.0, xs[-1] - xs[0])
        risk = (days_to is not None and days_to <= horizon) or out_n > 0
        out.append({"equipment_id": eid, "equipment": names.get(eid, ""), "item": text, "unit": unit or "", "min": lo, "max": hi,
                    "n": n, "last": ys[-1], "last_at": config.iso(pts[-1][0]), "trend_per_30d": round(slope * 30, 3),
                    "fit_now": round(fit_now, 3), "bound": bound,
                    "days_to_bound": None if days_to is None else round(max(0.0, days_to), 1),
                    "out_of_range": out_n, "nu_per_30d": round(out_n / span * 30, 3), "risk": risk})
    out.sort(key=lambda r: (not r["risk"], r["days_to_bound"] if r["days_to_bound"] is not None else 1e9, -r["out_of_range"]))
    return out


# ---------- выгрузки ----------
def _fmt(dt):
    return dt.strftime("%Y-%m-%d %H:%M") if dt else ""


def _num(v):
    return "" if v is None else str(round(v, 3)).replace(".", ",")


def export_failures(db: Session, start: datetime, end: datetime, equipment_ids: set[int] | None) -> str:
    """По одной строке на отказ или неисправность за период — для расчётов в Excel или Python."""
    eqs = {e.id: e for e in db.scalars(select(Equipment))}
    locs = dict(db.execute(select(Location.id, Location.name)).all())
    deps = dict(db.execute(select(Department.id, Department.name)).all())
    units = {u.id: u.name for u in db.scalars(select(ServiceUnit))}
    buf = io.StringIO()
    w = csv.writer(buf, delimiter=";")
    w.writerow(["№", "Машина", "Инв. №", "Место", "Отдел", "Тип", "Статус", "Источник", "Зарегистрировано", "Переведено в отказ",
                "Начало работ", "Ввод в эксплуатацию", "Закрыто", "Простой, ч", "Ремонт, ч", "Ожидание запчастей, ч",
                "Наработка при регистрации", "Наработка при отказе", "Показание при вводе", "Узел-причина", "Причина", "Характер",
                "Что сделано", "Заменённые узлы", "Признаки заранее", "Что случилось", "Описание устранения"])
    q = select(Incident).where(Incident.occurred_at >= start, Incident.occurred_at < end).order_by(Incident.occurred_at)
    for i in db.scalars(q):
        if equipment_ids is not None and i.equipment_id not in equipment_ids:
            continue
        e = eqs.get(i.equipment_id)
        fa = failure_at(i)
        down = (i.restored_at - fa).total_seconds() / 3600 if i.restored_at and i.kind == "incident" else None
        rep = (i.restored_at - i.repair_started_at).total_seconds() / 3600 if i.restored_at and i.repair_started_at else None
        w.writerow([i.id, e.name if e else "", e.inventory_no if e else "", locs.get(e.location_id, "") if e else "",
                    deps.get(e.department_id, "") if e else "", "отказ" if i.kind == "incident" else "неисправность",
                    "открыт" if i.status == "open" else "закрыт", {"staff": "сотрудник", "public": "публичная форма", "api": "внешняя система"}.get(i.source, i.source),
                    _fmt(i.occurred_at), _fmt(i.escalated_at), _fmt(i.repair_started_at), _fmt(i.restored_at), _fmt(i.closed_at),
                    _num(down), _num(rep), _num(i.parts_wait_hours), _num(i.hours_at_open), _num(i.hours_at_failure), _num(i.meter_at_restore),
                    units.get(i.cause_unit_id, "") or i.cause_unit_other, CAUSE_RU.get(i.cause, ""), NATURE_RU.get(i.nature, ""),
                    ACTION_RU.get(i.action, ""), ", ".join(u.unit_name for u in i.units if u.replaced),
                    PRECURSOR_RU.get(i.precursor, ""), i.title + (": " + i.description if i.description else ""), i.close_note])
    return "" + buf.getvalue()


def export_service_events(db: Session, start: datetime, end: datetime, equipment_ids: set[int] | None) -> str:
    """История обслуживания узлов: плановые замены — «цензурированные» наблюдения (узел заменили, не дождавшись отказа)."""
    eqs = {e.id: e for e in db.scalars(select(Equipment))}
    units = {u.id: u for u in db.scalars(select(ServiceUnit))}
    buf = io.StringIO()
    w = csv.writer(buf, delimiter=";")
    w.writerow(["Машина", "Инв. №", "Узел", "Когда", "Наработка машины, м/ч", "Вид", "Наряд", "Комментарий"])
    q = select(ServiceEvent).where(ServiceEvent.at >= start, ServiceEvent.at < end).order_by(ServiceEvent.unit_id, ServiceEvent.at)
    for ev in db.scalars(q):
        u = units.get(ev.unit_id)
        if not u or (equipment_ids is not None and u.equipment_id not in equipment_ids):
            continue
        e = eqs.get(u.equipment_id)
        w.writerow([e.name if e else "", e.inventory_no if e else "", u.name, _fmt(ev.at), _num(ev.hours),
                    SERVICE_KIND_RU.get(ev.kind, ev.kind), ev.order_id or "", ev.note])
    return "" + buf.getvalue()