"""Stream-scan InMark-style logs without loading the whole file into RAM."""

from __future__ import annotations

import gzip
import re
from collections import Counter
from datetime import datetime
from pathlib import Path
from typing import Any, Callable, Iterable

ProgressCb = Callable[[dict[str, Any]], None]

LOG_JOB_HINTS = re.compile(
    r"job[_\s]?id|заказ|расхожден|error\s*6[45]|промежутк|частот|"
    r"plc_errors|line_u|задани[еюя]|маркиров|отбраков|лог[аиов]?\b|"
    r"histogram|ошибк|gap|код[аыов]?\b|смен[аыеу]",
    re.IGNORECASE,
)
JOB_ID_RE = re.compile(
    r"(?:job(?:[_\s-]?id)?|заказ(?:а|у|ом)?|задани[еюя]|jobid)\s*[:=#№]?\s*(\d{3,8})",
    re.IGNORECASE,
)
STANDALONE_JOB_RE = re.compile(r"\b(\d{4,6})\b")
DATE_ISO_RE = re.compile(r"\b(20\d{2}-\d{2}-\d{2})\b")
DATE_RU_RE = re.compile(r"\b(\d{1,2})[./](\d{1,2})[./](20\d{2}|\d{2})\b")
TS_ISO_RE = re.compile(r"(20\d{2}-\d{2}-\d{2})[ T](\d{2}:\d{2}:\d{2})")
TS_RU_RE = re.compile(r"(\d{2}\.\d{2}\.20\d{2})[ T](\d{2}:\d{2}:\d{2})")
SOURCE_BRACKET_RE = re.compile(r"\[([A-Za-zА-Яа-яЁё0-9_./-]{2,40})\]")
SOURCE_FIELD_RE = re.compile(
    r"\b(?:source|src|sender|from|channel|канал)\s*[=:]\s*([^\s,;\]=]+)",
    re.IGNORECASE,
)
ERROR_RE = re.compile(r"\b(?:Error|error_?)\s*(\d{1,3})\b")
ERROR64_RE = re.compile(r"\b(?:Error|error_?)\s*64\b", re.IGNORECASE)
ERROR65_RE = re.compile(r"\b(?:Error|error_?)\s*65\b", re.IGNORECASE)
JOB_IN_LINE_RE = re.compile(
    r"(?:job(?:[_\s-]?id)?|заказ|JobId)\s*[=:#]?\s*(\d{3,8})",
    re.IGNORECASE,
)
CODE_RE = re.compile(
    r"\b(?:01\d{14}21[A-Za-z0-9]{1,24}|[A-F0-9]{24,44}|\d{20,32})\b"
)
LOG_NAME_RE = re.compile(r"\.log(\.\d+)?(\.gz)?$", re.IGNORECASE)

PREFERRED_LOG_NAMES = (
    "line_u_codes.log",
    "plc_errors.log",
    "line_u.log",
    "line.log",
)

GAP_SECONDS = 30
MAX_UNIQUE_CODES = 20_000
MAX_ERROR64_HITS = 80
MAX_GAPS = 25
MAX_SAMPLE_LINES = 12
MAX_PREANALYSIS_CHARS = 70_000
READ_CHUNK = 256 * 1024


def looks_like_log_job(query: str, log_file_names: Iterable[str] | None = None) -> bool:
    text = str(query or "")
    if LOG_JOB_HINTS.search(text):
        return True
    names = [str(name or "") for name in (log_file_names or [])]
    if names and (JOB_ID_RE.search(text) or DATE_ISO_RE.search(text) or DATE_RU_RE.search(text)):
        return True
    return False


def is_log_filename(name: str) -> bool:
    lower = str(name or "").lower()
    if LOG_NAME_RE.search(lower):
        return True
    return ".log." in lower or lower.endswith(".log")


def detect_job_id(query: str) -> str | None:
    text = str(query or "")
    match = JOB_ID_RE.search(text)
    if match:
        return match.group(1)
    hinted = LOG_JOB_HINTS.search(text)
    if hinted:
        standalone = STANDALONE_JOB_RE.search(text)
        if standalone:
            return standalone.group(1)
    return None


def detect_shift_date(query: str) -> str | None:
    text = str(query or "")
    iso = DATE_ISO_RE.search(text)
    if iso:
        return iso.group(1)
    ru = DATE_RU_RE.search(text)
    if not ru:
        return None
    day, month, year = ru.group(1), ru.group(2), ru.group(3)
    if len(year) == 2:
        year = f"20{year}"
    try:
        return datetime(int(year), int(month), int(day)).strftime("%Y-%m-%d")
    except ValueError:
        return None


def detect_log_encoding(path: Path) -> str:
    try:
        raw = path.open("rb").read(65536)
    except OSError:
        return "utf-8"
    if raw.startswith(b"\xef\xbb\xbf"):
        return "utf-8-sig"
    for encoding in ("utf-8", "cp1251"):
        try:
            raw.decode(encoding)
            return encoding
        except UnicodeDecodeError:
            continue
    return "cp1251"


def _parse_timestamp(line: str) -> datetime | None:
    match = TS_ISO_RE.search(line)
    if match:
        try:
            return datetime.strptime(
                f"{match.group(1)} {match.group(2)}", "%Y-%m-%d %H:%M:%S"
            )
        except ValueError:
            return None
    match = TS_RU_RE.search(line)
    if not match:
        return None
    try:
        return datetime.strptime(
            f"{match.group(1)} {match.group(2)}", "%d.%m.%Y %H:%M:%S"
        )
    except ValueError:
        return None


def _source_of(line: str, fallback: str) -> str:
    field = SOURCE_FIELD_RE.search(line)
    if field:
        return field.group(1)[:40]
    bracket = SOURCE_BRACKET_RE.search(line)
    if bracket:
        token = bracket.group(1)
        if not re.fullmatch(r"\d{1,2}:\d{2}:\d{2}.*", token):
            return token[:40]
    return fallback


def _open_log_binary(path: Path):
    name = path.name.lower()
    handle = path.open("rb")
    if name.endswith(".gz"):
        return gzip.GzipFile(fileobj=handle, mode="rb"), handle
    return handle, handle


def iter_log_lines(path: Path, encoding: str):
    """Yield (line_no, text, bytes_read, total_bytes) without loading the file."""
    size = 0
    try:
        size = path.stat().st_size
    except OSError:
        size = 0
    stream, raw = _open_log_binary(path)
    try:
        leftover = b""
        line_no = 0
        bytes_read = 0
        while True:
            chunk = stream.read(READ_CHUNK)
            if not chunk:
                break
            bytes_read += len(chunk)
            data = leftover + chunk
            parts = data.split(b"\n")
            leftover = parts.pop()
            for part in parts:
                line_no += 1
                text = part.rstrip(b"\r").decode(encoding, errors="replace")
                yield line_no, text, min(bytes_read, size) if size else bytes_read, size
        if leftover:
            line_no += 1
            text = leftover.rstrip(b"\r").decode(encoding, errors="replace")
            yield line_no, text, size or bytes_read, size
    finally:
        try:
            stream.close()
        except Exception:  # noqa: BLE001
            pass
        if raw is not stream:
            try:
                raw.close()
            except Exception:  # noqa: BLE001
                pass


def rank_log_files(entries: list[dict]) -> list[dict]:
    def score(entry: dict) -> tuple:
        name = str(entry.get("name") or "").lower()
        preferred = 0
        for index, prefix in enumerate(PREFERRED_LOG_NAMES):
            if name.startswith(prefix) or prefix in name:
                preferred = 10 - index
                break
        size = int(entry.get("size") or 0)
        return (preferred, 1 if is_log_filename(name) else 0, min(size, 10**12))

    logs = [entry for entry in entries if is_log_filename(str(entry.get("name") or ""))]
    logs.sort(key=score, reverse=True)
    return logs[:6]


def _emit_progress(
    on_progress: ProgressCb | None,
    *,
    phase: str,
    message: str,
    percent: int | None,
    file: str = "",
) -> None:
    if not on_progress:
        return
    payload: dict[str, Any] = {
        "phase": phase,
        "message": message,
        "percent": percent,
    }
    if file:
        payload["file"] = file
    on_progress(payload)


def _scan_one_file(
    path: Path,
    display_name: str,
    job_id: str | None,
    shift_date: str | None,
    *,
    on_progress: ProgressCb | None = None,
    overall_offset: int = 0,
    overall_total: int = 1,
    cancel: Callable[[], bool] | None = None,
) -> dict[str, Any]:
    encoding = detect_log_encoding(path)
    sources: Counter[str] = Counter()
    errors: Counter[str] = Counter()
    hours: Counter[str] = Counter()
    unique_codes: set[str] = set()
    unique_capped = False
    code_events = 0
    error64: list[dict[str, Any]] = []
    error65: list[dict[str, Any]] = []
    gaps: list[dict[str, Any]] = []
    samples: list[dict[str, Any]] = []
    first_ts: datetime | None = None
    last_ts: datetime | None = None
    prev_ts: datetime | None = None
    prev_line = 0
    line_count = 0
    job_lines = 0
    shift_lines = 0
    last_pct = -1

    def maybe_sample(line_no: int, line: str, reason: str) -> None:
        if len(samples) >= MAX_SAMPLE_LINES:
            return
        samples.append(
            {
                "file": display_name,
                "line": line_no,
                "text": line[:240],
                "reason": reason,
            }
        )

    for line_no, line, bytes_read, total in iter_log_lines(path, encoding):
        if cancel and cancel():
            break
        line_count = line_no
        if overall_total:
            local = (bytes_read / total) if total else 1.0
            overall = overall_offset + local * (total or 0)
            pct = min(99, int(100 * overall / overall_total))
            if pct >= last_pct + 2:
                last_pct = pct
                _emit_progress(
                    on_progress,
                    phase="scan",
                    message=f"Читаю лог… {pct}%",
                    percent=pct,
                    file=display_name,
                )

        ts = _parse_timestamp(line)
        if ts:
            if first_ts is None:
                first_ts = ts
                maybe_sample(line_no, line, "first")
            last_ts = ts
            hours[ts.strftime("%Y-%m-%d %H:00")] += 1
            if prev_ts is not None:
                delta = (ts - prev_ts).total_seconds()
                if delta >= GAP_SECONDS:
                    gaps.append(
                        {
                            "file": display_name,
                            "from_line": prev_line,
                            "to_line": line_no,
                            "from_ts": prev_ts.isoformat(sep=" ", timespec="seconds"),
                            "to_ts": ts.isoformat(sep=" ", timespec="seconds"),
                            "seconds": int(delta),
                        }
                    )
            prev_ts = ts
            prev_line = line_no

        in_shift = True
        if shift_date and ts:
            in_shift = ts.strftime("%Y-%m-%d") == shift_date
        elif shift_date and shift_date in line:
            in_shift = True
        elif shift_date:
            in_shift = False
        if in_shift:
            shift_lines += 1

        job_hit = JOB_IN_LINE_RE.search(line)
        if job_id and (job_id in line or (job_hit and job_hit.group(1) == job_id)):
            job_lines += 1
        elif job_hit:
            job_lines += 0

        sources[_source_of(line, display_name)] += 1

        for err in ERROR_RE.findall(line):
            if in_shift or not shift_date:
                errors[err] += 1

        if ERROR64_RE.search(line) and len(error64) < MAX_ERROR64_HITS:
            error64.append(
                {
                    "file": display_name,
                    "line": line_no,
                    "ts": ts.isoformat(sep=" ", timespec="seconds") if ts else "",
                    "text": line[:220],
                }
            )
            maybe_sample(line_no, line, "Error64")
        if ERROR65_RE.search(line) and len(error65) < MAX_ERROR64_HITS:
            error65.append(
                {
                    "file": display_name,
                    "line": line_no,
                    "ts": ts.isoformat(sep=" ", timespec="seconds") if ts else "",
                    "text": line[:220],
                }
            )
            maybe_sample(line_no, line, "Error65")

        for code in CODE_RE.findall(line):
            code_events += 1
            if not unique_capped:
                unique_codes.add(code)
                if len(unique_codes) >= MAX_UNIQUE_CODES:
                    unique_capped = True

    if last_ts and line_count:
        maybe_sample(line_count, "", "last")
        if samples and samples[-1]["reason"] == "last" and not samples[-1]["text"]:
            samples.pop()

    gaps.sort(key=lambda item: int(item.get("seconds") or 0), reverse=True)
    gaps = gaps[:MAX_GAPS]

    return {
        "file": display_name,
        "path": str(path),
        "encoding": encoding,
        "lines": line_count,
        "job_lines": job_lines,
        "shift_lines": shift_lines,
        "first_ts": first_ts.isoformat(sep=" ", timespec="seconds") if first_ts else "",
        "last_ts": last_ts.isoformat(sep=" ", timespec="seconds") if last_ts else "",
        "sources": sources.most_common(30),
        "errors": errors.most_common(25),
        "hours": hours.most_common(24),
        "unique_codes": len(unique_codes),
        "unique_capped": unique_capped,
        "code_events": code_events,
        "error64": error64,
        "error65": error65,
        "gaps": gaps,
        "samples": samples,
    }


def _format_duration(seconds: int) -> str:
    value = max(0, int(seconds))
    if value < 60:
        return f"{value} с"
    minutes, rest = divmod(value, 60)
    if minutes < 60:
        return f"{minutes} мин {rest} с" if rest else f"{minutes} мин"
    hours, minutes = divmod(minutes, 60)
    return f"{hours} ч {minutes} мин"


def render_preanalysis_markdown(report: dict[str, Any]) -> str:
    job_id = report.get("job_id") or "не найден в вопросе"
    shift = report.get("shift_date") or "не указана"
    lines: list[str] = [
        "# PREANALYSIS",
        "",
        "Сервер уже просканировал логи **одним проходом**. "
        "Используй этот файл первым. Не читай логи целиком заново, "
        "если цифры выглядят правдоподобно. Для проверки бери фрагмент "
        "по номеру строки (`:15231:line_u_codes.log.1` или "
        "`::log:line_u_codes.log.1:15231::`).",
        "",
        f"- Job id: `{job_id}`",
        f"- Дата смены (из вопроса): `{shift}`",
        f"- Файлов просканировано: {len(report.get('files') or [])}",
        "",
    ]

    for item in report.get("files") or []:
        name = item.get("file") or "log"
        lines.extend(
            [
                f"## {name}",
                "",
                f"- Кодировка: `{item.get('encoding')}`",
                f"- Строк: {item.get('lines')}",
                f"- Строк с job id: {item.get('job_lines')}",
                f"- Строк за смену: {item.get('shift_lines')}",
                f"- Интервал: {item.get('first_ts') or '—'} → {item.get('last_ts') or '—'}",
                f"- Событий с кодами: {item.get('code_events')}",
                f"- Уникальных кодов: {item.get('unique_codes')}"
                + (" (учёт ограничен) " if item.get("unique_capped") else ""),
                "",
                "### Источники",
                "",
            ]
        )
        sources = item.get("sources") or []
        if sources:
            for src, count in sources:
                lines.append(f"- `{src}`: {count}")
        else:
            lines.append("- (нет)")
        lines.extend(["", "### Ошибки за смену (гистограмма)", ""])
        errors = item.get("errors") or []
        if errors:
            for code, count in errors:
                lines.append(f"- Error {code}: {count}")
        else:
            lines.append("- (нет совпадений Error N)")
        lines.extend(["", "### Частота по часам (топ)", ""])
        hours = item.get("hours") or []
        if hours:
            for hour, count in hours[:16]:
                lines.append(f"- {hour}: {count}")
        else:
            lines.append("- (нет меток времени)")
        lines.extend(["", "### Длинные промежутки (≥ 30 с)", ""])
        gaps = item.get("gaps") or []
        if gaps:
            for gap in gaps:
                lines.append(
                    f"- {_format_duration(int(gap.get('seconds') or 0))}: "
                    f"{gap.get('from_ts')} → {gap.get('to_ts')} "
                    f"(`:{gap.get('from_line')}:{name}` … `:{gap.get('to_line')}:{name}`)"
                )
        else:
            lines.append("- нет промежутков ≥ 30 с")
        lines.extend(["", "### Error64", ""])
        hits64 = item.get("error64") or []
        if hits64:
            for hit in hits64[:40]:
                ts = hit.get("ts") or "—"
                lines.append(
                    f"- {ts} `:{hit.get('line')}:{name}` — {hit.get('text')}"
                )
        else:
            lines.append("- нет")
        lines.extend(["", "### Error65", ""])
        hits65 = item.get("error65") or []
        if hits65:
            for hit in hits65[:40]:
                ts = hit.get("ts") or "—"
                lines.append(
                    f"- {ts} `:{hit.get('line')}:{name}` — {hit.get('text')}"
                )
        else:
            lines.append("- нет")
        lines.extend(["", "### Примеры строк", ""])
        for sample in item.get("samples") or []:
            text = str(sample.get("text") or "").strip()
            if not text:
                continue
            lines.append(
                f"- `:{sample.get('line')}:{name}` ({sample.get('reason')}): `{text}`"
            )
        lines.append("")

    text = "\n".join(lines).strip() + "\n"
    if len(text) > MAX_PREANALYSIS_CHARS:
        text = text[:MAX_PREANALYSIS_CHARS].rstrip() + "\n\n…\n"
    return text


def preanalyze_logs(
    files: list[tuple[Path, str]],
    query: str,
    *,
    on_progress: ProgressCb | None = None,
    cancel: Callable[[], bool] | None = None,
) -> dict[str, Any]:
    job_id = detect_job_id(query)
    shift_date = detect_shift_date(query)
    existing = [(path, name) for path, name in files if path.exists() and path.is_file()]
    total_bytes = 0
    for path, _name in existing:
        try:
            total_bytes += path.stat().st_size
        except OSError:
            pass
    total_bytes = max(total_bytes, 1)
    offset = 0
    scanned: list[dict[str, Any]] = []
    _emit_progress(
        on_progress,
        phase="scan",
        message="Читаю лог… 0%",
        percent=0,
    )
    for path, name in existing:
        size = 0
        try:
            size = path.stat().st_size
        except OSError:
            size = 0
        item = _scan_one_file(
            path,
            name,
            job_id,
            shift_date,
            on_progress=on_progress,
            overall_offset=offset,
            overall_total=total_bytes,
            cancel=cancel,
        )
        scanned.append(item)
        offset += size
        if cancel and cancel():
            break
    _emit_progress(
        on_progress,
        phase="scan",
        message="Читаю лог… 100%",
        percent=100,
    )
    report = {
        "job_id": job_id or "",
        "shift_date": shift_date or "",
        "files": scanned,
    }
    report["markdown"] = render_preanalysis_markdown(report)
    report["summary"] = _short_summary(report)
    return report


def _short_summary(report: dict[str, Any]) -> str:
    bits = []
    if report.get("job_id"):
        bits.append(f"job {report['job_id']}")
    if report.get("shift_date"):
        bits.append(report["shift_date"])
    for item in report.get("files") or []:
        bits.append(
            f"{item.get('file')}: {item.get('lines')} строк, "
            f"Error64×{len(item.get('error64') or [])}, "
            f"промежутков {len(item.get('gaps') or [])}"
        )
    return "; ".join(bits) if bits else "логи просканированы"


def excerpt_lines(
    path: Path,
    start: int,
    end: int,
    encoding: str | None = None,
) -> tuple[str, str]:
    """Return (text, encoding) for 1-indexed inclusive line range."""
    start = max(1, int(start))
    end = max(start, int(end))
    encoding = encoding or detect_log_encoding(path)
    collected: list[str] = []
    for line_no, text, _read, _total in iter_log_lines(path, encoding):
        if line_no < start:
            continue
        if line_no > end:
            break
        collected.append(f"{line_no}\t{text}")
    return "\n".join(collected) + ("\n" if collected else ""), encoding


def write_preanalysis_md(workspace: Path, markdown: str) -> Path:
    target = Path(workspace) / "PREANALYSIS.md"
    target.write_text(markdown, encoding="utf-8")
    listing = Path(workspace) / "PROJECT_FILES.md"
    if listing.exists():
        extra = "\n- ./PREANALYSIS.md — server-side log scan; read this first\n"
        text = listing.read_text(encoding="utf-8")
        if "PREANALYSIS.md" not in text:
            listing.write_text(text.rstrip() + extra, encoding="utf-8")
    return target