"""Kufar FTP feed workspace. Version 2026.11.10.8, 10.11.2026 MSK.

The remote XML is the baseline; local edits never publish implicitly.
SQLite and DPAPI credentials live beside the other local catalogues.
"""
from __future__ import annotations

import base64
import copy
import ctypes
import ftplib
import hashlib
import io
import json
import posixpath
import re
import sqlite3
import ssl
import uuid
import xml.etree.ElementTree as ET
from collections import Counter
import httpx
from contextlib import contextmanager
from datetime import datetime, timezone
from decimal import Decimal, InvalidOperation
from pathlib import Path
from urllib.parse import urlsplit, quote

LIMIT = 300
STANDARD_DESCRIPTION_TEXT = (
    "В случае оформления заказа через сайт и оплате наличными или банковской картой "
    "СКИДКА 5%. После подтверждения заказа скидка будет применена.\n"
    "*скидка не действует при оплате картами рассрочек и оплате частями"
)
STANDARD_DESCRIPTION_MARKER = (
    "в случае оформления заказа через сайт и оплате наличными или банковской картой"
)


def with_standard_description(body, enabled=True):
    body = (body or "").strip()
    if not enabled or STANDARD_DESCRIPTION_MARKER in body.casefold():
        return body
    return body + ("\n\n" if body else "") + STANDARD_DESCRIPTION_TEXT


def import_unid(product_id):
    """Reversible ASCII transport key; retain the original nomenclature separately.

    2026.11.04.4: Kufar's documented UNID alphabet is Latin letters and digits.
    Existing imported UNIDs are never rewritten.
    """
    match = re.fullmatch(r"(\d+)-(БК|расп)-(\d+)", product_id, re.I)
    if not match:
        raise Error("Нужен полный уникальный код БК/расп.")
    return match[1] + ("BK" if match[2].casefold() == "бк" else "RASP") + match[3]

def categories():
    data = json.loads(Path(__file__).with_name("kufar_categories.json").read_text(encoding="utf-8"))
    for definition in data.values():
        terms = [definition["label"]]
        for field in definition.get("fields", []):
            terms.append(field.get("label", ""))
            terms.extend(label for _, label in field.get("options", []))
        definition["search"] = " ".join(filter(None, terms))
    return data

MAX_XML = 20 * 1024 * 1024
MAX_PHOTO = 15 * 1024 * 1024
MAX_PHOTOS = 15

# These seller fields are accepted by the Kufar revision 5 catalogue across
# the goods categories used by the company.  Unlike required category fields,
# they are optional in the feed, but keeping them separate makes them appear
# as characteristics instead of burying them in the description.
OPTIONAL_SHOP_FIELDS = (
    ("shop_guarantee", "Гарантийный срок"),
    ("shop_manufacturer", "Производитель / импортёр"),
    ("shop_service", "Сервисная / ремонтная организация"),
    ("shop_manufacturer_country", "Страна-производитель"),
    ("other_parameters", "Дополнительные характеристики"),
)


class Error(ValueError):
    pass


def now():
    return datetime.now(timezone.utc).isoformat(timespec="microseconds")


def digest(data):
    return hashlib.sha256(data).hexdigest()


def protect(text, decrypt=False):
    """Windows user-bound DPAPI; never persist plaintext passwords."""
    if not hasattr(ctypes, "windll"):
        raise Error("Хранение пароля поддерживается только через Windows DPAPI.")
    class Blob(ctypes.Structure):
        _fields_ = [("size", ctypes.c_ulong), ("data", ctypes.POINTER(ctypes.c_ubyte))]
    raw = base64.b64decode(text) if decrypt else text.encode("utf-8")
    buffer = ctypes.create_string_buffer(raw)
    source = Blob(len(raw), ctypes.cast(buffer, ctypes.POINTER(ctypes.c_ubyte)))
    result = Blob()
    method = ctypes.windll.crypt32.CryptUnprotectData if decrypt else ctypes.windll.crypt32.CryptProtectData
    if not method(ctypes.byref(source), None, None, None, None, 1, ctypes.byref(result)):
        raise Error("Не удалось открыть пароль хостинга под текущей учётной записью Windows.")
    try:
        value = ctypes.string_at(result.data, result.size)
        return value.decode("utf-8") if decrypt else base64.b64encode(value).decode("ascii")
    finally:
        ctypes.windll.kernel32.LocalFree(result.data)


@contextmanager
def connect(root):
    root = Path(root)
    root.mkdir(parents=True, exist_ok=True)
    conn = sqlite3.connect(root / "workspace.sqlite3", timeout=5)
    conn.row_factory = sqlite3.Row
    conn.execute("CREATE TABLE IF NOT EXISTS state (id INTEGER PRIMARY KEY CHECK(id=1), config TEXT NOT NULL DEFAULT '{}', baseline BLOB, hash TEXT, synced_at TEXT, published_at TEXT, revision INTEGER NOT NULL DEFAULT 0)")
    conn.execute("INSERT OR IGNORE INTO state(id) VALUES(1)")
    columns = {r[1] for r in conn.execute("PRAGMA table_info(state)")}
    if "manual_count" not in columns:
        conn.execute("ALTER TABLE state ADD COLUMN manual_count INTEGER")
        conn.execute("ALTER TABLE state ADD COLUMN manual_checked_at TEXT")
    conn.execute("CREATE TABLE IF NOT EXISTS listing (unid TEXT PRIMARY KEY, draft TEXT, removed INTEGER NOT NULL DEFAULT 0, product_id TEXT NOT NULL DEFAULT '', version INTEGER NOT NULL DEFAULT 0)")
    if "source_xml" not in {r[1] for r in conn.execute("PRAGMA table_info(listing)")}:
        conn.execute("ALTER TABLE listing ADD COLUMN source_xml BLOB")
    conn.execute("CREATE TABLE IF NOT EXISTS archive (unid TEXT NOT NULL, at TEXT NOT NULL, record_xml BLOB NOT NULL, product_id TEXT NOT NULL, PRIMARY KEY(unid,at))")
    conn.execute("CREATE TABLE IF NOT EXISTS event (id INTEGER PRIMARY KEY, at TEXT NOT NULL, actor INTEGER, action TEXT NOT NULL, detail TEXT NOT NULL)")
    conn.commit()
    try:
        # Serialize local edits, settings and remote operations across processes.
        conn.execute("BEGIN IMMEDIATE")
        yield conn
        conn.commit()
    except Exception:
        conn.rollback()
        raise
    finally:
        conn.close()


def audit(conn, uid, action, detail):
    conn.execute("INSERT INTO event(at,actor,action,detail) VALUES(?,?,?,?)", (now(), uid, action, detail))


def parse(data):
    if not data or len(data) > MAX_XML:
        raise Error("Файл XML пуст или превышает 20 МБ.")
    # Reject encoded DTDs as well as UTF-8 declarations before parsing.
    if b"<!DOCTYPE" in data.upper().replace(b"\x00", b"") or b"<!ENTITY" in data.upper().replace(b"\x00", b""):
        raise Error("DTD и внешние сущности в XML запрещены.")
    try:
        parser = ET.XMLParser(target=ET.TreeBuilder(insert_comments=True, insert_pis=True))
        root = ET.fromstring(data, parser=parser)
    except ET.ParseError as exc:
        raise Error("Не удалось прочитать XML Kufar.") from exc
    if root.tag != "uedb" or len(root.findall("records")) != 1:
        raise Error("Ожидается XML со структурой uedb/records/record.")
    records = root.find("records")
    items = {}
    for record in records:
        if record.tag is not ET.Comment and record.tag is not ET.ProcessingInstruction and record.tag != "record":
            raise Error("Неизвестная структура списка объявлений.")
        if record.tag != "record":
            continue
        unid = (record.findtext("unid") or "").strip()
        if not unid or len(record.findall("unid")) != 1 or unid in items:
            raise Error("В файле есть пустой или повторяющийся UNID. Сверка отменена.")
        items[unid] = record
    return root, items


def fields(record):
    return {"subject": record.findtext("subject", ""), "body": record.findtext("body", ""),
            "price": record.findtext("price", ""), "photos": [p.get("picture", "") for p in record.findall("photos/photo")]}


def public_url(value):
    parsed = urlsplit(value)
    if parsed.scheme not in {"http", "https"} or not parsed.hostname or parsed.username or parsed.password or any(c in value for c in "\r\n"):
        raise Error("Укажите публичный HTTP/HTTPS адрес без логина и пароля.")
    return value


def photo_plan(raw, urls, upload_count):
    """Validate the mixed URL/upload order posted by the photo editor.

    The XML order is significant: the first photo becomes the main image.
    A complete plan is required so a stale browser cannot silently omit a
    selected file or a pasted link.
    """
    urls = [value.strip() for value in urls if value.strip()]
    if len(urls) != len(set(urls)):
        raise Error("Одинаковая ссылка на фото указана несколько раз.")
    if not raw:
        plan = [("url", value) for value in urls]
        plan.extend(("file", index) for index in range(upload_count))
    else:
        try:
            posted = json.loads(raw)
        except (TypeError, json.JSONDecodeError) as exc:
            raise Error("Не удалось прочитать порядок фотографий. Обновите список фото.") from exc
        if not isinstance(posted, list):
            raise Error("Не удалось прочитать порядок фотографий. Обновите список фото.")
        plan = []
        for item in posted:
            if not isinstance(item, dict) or item.get("kind") not in {"url", "file"}:
                raise Error("Не удалось прочитать порядок фотографий. Обновите список фото.")
            if item["kind"] == "url":
                value = str(item.get("value", "")).strip()
                plan.append(("url", value))
            else:
                try:
                    index = int(item.get("index"))
                except (TypeError, ValueError) as exc:
                    raise Error("Не удалось прочитать порядок загруженных фотографий.") from exc
                plan.append(("file", index))
        if Counter(value for kind, value in plan if kind == "url") != Counter(urls):
            raise Error("Список ссылок изменился. Обновите порядок фотографий.")
        file_indexes = [value for kind, value in plan if kind == "file"]
        if sorted(file_indexes) != list(range(upload_count)):
            raise Error("Список файлов изменился. Выберите фотографии ещё раз.")
    if not plan:
        raise Error("Добавьте настоящую фотографию продаваемого товара.")
    if len(plan) > MAX_PHOTOS:
        raise Error(f"В объявлении может быть не более {MAX_PHOTOS} фотографий.")
    return plan


def validate(draft):
    if not 2 <= len(draft["subject"].strip()) <= 100:
        raise Error("Заголовок должен содержать от 2 до 100 символов.")
    if not 20 <= len(draft["body"].strip()) <= 4000:
        raise Error("Описание должно содержать от 20 до 4000 символов.")
    try:
        price = Decimal(draft["price"])
        if not price.is_finite() or price < 0 or price.as_tuple().exponent < -2:
            raise InvalidOperation
    except (InvalidOperation, ValueError):
        raise Error("Цена должна быть неотрицательным числом с точностью до копеек.")
    draft["price"] = format(price, ".2f")
    if not draft["photos"]:
        raise Error("Добавьте настоящую фотографию продаваемого товара.")
    if len(draft["photos"]) > MAX_PHOTOS:
        raise Error(f"В объявлении может быть не более {MAX_PHOTOS} фотографий.")
    if len(draft["photos"]) != len(set(draft["photos"])):
        raise Error("Одинаковая фотография указана несколько раз.")
    for photo in draft["photos"]:
        public_url(photo)
    return draft


def build(baseline, rows):
    root, records = parse(baseline)
    container = root.find("records")
    remaining = len(records)
    for row in rows:
        record = records.get(row["unid"])
        if record is None and row.get("source_xml"):
            record = ET.fromstring(row["source_xml"])
            container.append(record)
            remaining += 1
        if record is None:
            raise Error("Список объявлений изменился. Повторите сверку.")
        if row["removed"]:
            container.remove(record)
            remaining -= 1
        elif row["draft"]:
            draft = validate(json.loads(row["draft"]))
            for tag in ("subject", "body", "price"):
                node = record.find(tag)
                if node is None:
                    node = ET.SubElement(record, tag)
                node.text = draft[tag]
            old = record.find("photos")
            old_urls = fields(record)["photos"]
            if old_urls != draft["photos"]:
                # Preserve attributes/metadata for unchanged photographs.
                saved = {p.get("picture"): copy.deepcopy(p) for p in record.findall("photos/photo")}
                if old is not None:
                    record.remove(old)
                if draft["photos"]:
                    photos = ET.SubElement(record, "photos")
                    for url in draft["photos"]:
                        photos.append(saved[url] if url in saved else ET.Element("photo", {"picture": url}))
    if remaining > LIMIT:
        raise Error(f"В файле {remaining} объявлений. Лимит — {LIMIT}.")
    return ET.tostring(root, encoding="utf-8", xml_declaration=True)


def safe_path(value):
    if not value or "\\" in value or any(c in value for c in "\r\n\x00") or ".." in value.split("/"):
        raise Error("Некорректный путь FTP.")
    return value


class Remote:
    def __init__(self, config):
        self.config = config
        self.ftp = None

    def __enter__(self):
        c = self.config
        if not c.get("host") or not c.get("secret"):
            raise Error("Сначала сохраните адрес хостинга, логин и пароль.")
        ftp = ftplib.FTP_TLS(context=ssl.create_default_context(), timeout=45) if c.get("protocol") == "ftps" else ftplib.FTP(timeout=45)
        self.ftp = ftp
        try:
            ftp.connect(c["host"], int(c.get("port", 21)))
            # Connect to the supplied IP while verifying the provider's certificate name.
            if c.get("tls_name"):
                ftp.host = c["tls_name"]
            ftp.login(c["username"], protect(c["secret"], decrypt=True))
            if c.get("protocol") == "ftps":
                ftp.prot_p()
            ftp.set_pasv(True)
            return self
        except Exception:
            ftp.close()
            raise

    def __exit__(self, *args):
        self.ftp.close()

    def read(self, path, limit=MAX_XML):
        stream = io.BytesIO()
        def receive(chunk):
            if stream.tell() + len(chunk) > limit:
                raise Error("Файл на хостинге превышает допустимый размер.")
            stream.write(chunk)
        self.ftp.retrbinary("RETR " + safe_path(path), receive)
        return stream.getvalue()

    def write_verified(self, path, data):
        self.ftp.storbinary("STOR " + safe_path(path), io.BytesIO(data))
        if digest(self.read(path, max(MAX_XML, len(data)))) != digest(data):
            raise Error("Проверка загруженного файла не пройдена.")

    def publish(self, path, data, baseline):
        # Keep a verified backup; never delete the working file to make rename work.
        suffix = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ") + "-" + uuid.uuid4().hex[:8]
        self.write_verified(path + ".backup-" + suffix, baseline)
        temp = path + ".upload-" + suffix
        self.write_verified(temp, data)
        if digest(self.read(path)) != digest(baseline):
            raise Error("Файл на сервере изменился во время загрузки. Обновление отменено.")
        self.ftp.rename(temp, path)
        if digest(self.read(path)) != digest(data):
            raise Error("Не удалось подтвердить файл после переименования. Выполните сверку.")


def snapshot(conn):
    state = dict(conn.execute("SELECT * FROM state WHERE id=1").fetchone())
    state["config"] = json.loads(state["config"])
    state["rows"] = [dict(r) for r in conn.execute("SELECT * FROM listing ORDER BY unid")]
    return state


def save_config(conn, values, password, uid):
    old = snapshot(conn)
    c = dict(values)
    if c["protocol"] not in {"ftp", "ftps"}:
        raise Error("Поддерживаются FTP и FTPS (explicit TLS).")
    if not c["host"] or any(x in c["host"] for x in "/\\\r\n@"):
        raise Error("Укажите имя сервера без протокола и пути.")
    try:
        c["port"] = int(c["port"])
        if not 1 <= c["port"] <= 65535:
            raise ValueError
    except ValueError:
        raise Error("Неверный порт.")
    safe_path(c["feed_path"])
    safe_path(c["photo_path"])
    public_url(c["feed_url"])
    public_url(c["photo_url"])
    c["secret"] = protect(password) if password else old["config"].get("secret", "")
    if c != old["config"] and any(r["draft"] or r["removed"] or r["source_xml"] for r in old["rows"]):
        raise Error("Перед изменением подключения отправьте или отмените все черновики.")
    # A new endpoint always needs a fresh mandatory reconciliation.
    changed = c != old["config"]
    if changed and old["baseline"]:
        previous = parse(old["baseline"])[1]
        for row in old["rows"]:
            if row["unid"] in previous:
                conn.execute("INSERT INTO archive VALUES(?,?,?,?)", (row["unid"], now(), ET.tostring(previous[row["unid"]], encoding="utf-8"), row["product_id"]))
    conn.execute("UPDATE state SET config=?, baseline=CASE WHEN ? THEN NULL ELSE baseline END, hash=CASE WHEN ? THEN NULL ELSE hash END, synced_at=CASE WHEN ? THEN NULL ELSE synced_at END, revision=revision+1 WHERE id=1", (json.dumps(c), changed, changed, changed))
    if changed:
        conn.execute("DELETE FROM listing")
    audit(conn, uid, "settings", "Параметры подключения изменены")


def reconcile(conn, uid, remote_factory=Remote):
    s = snapshot(conn)
    if any(r["draft"] or r["removed"] or r["source_xml"] for r in s["rows"]):
        raise Error("Есть локальные изменения. Отправьте их или отмените перед сверкой.")
    with remote_factory(s["config"]) as remote:
        data = remote.read(s["config"].get("feed_path", ""))
    _, items = parse(data)
    old = {r["unid"]: r["product_id"] for r in s["rows"]}
    if s["baseline"]:
        _, previous = parse(s["baseline"])
        for unid, record in previous.items():
            if unid not in items:
                conn.execute("INSERT INTO archive VALUES(?,?,?,?)", (unid, now(), ET.tostring(record, encoding="utf-8"), old.get(unid, "")))
    conn.execute("DELETE FROM listing")
    for unid, record in items.items():
        # Only an exact full nomenclature key may be inferred; original SKU is ambiguous.
        matches = set(re.findall(r"(?<![\w-])\d+-(?:расп|БК)-\d+(?![\w-])", unid + " " + record.findtext("body", ""), re.I))
        mapping = old.get(unid, "") or (next(iter(matches)) if len(matches) == 1 else "")
        conn.execute("INSERT INTO listing(unid,product_id) VALUES(?,?)", (unid, mapping))
    conn.execute("UPDATE state SET baseline=?,hash=?,synced_at=?,revision=revision+1 WHERE id=1", (data, digest(data), now()))
    audit(conn, uid, "reconcile", f"Получено {len(items)} записей")


def save_listing(conn, unid, version, revision, draft, removed, product_id, uid):
    s = snapshot(conn)
    if not s["baseline"] or s["revision"] != revision:
        raise Error("Сверка изменилась. Обновите страницу.")
    _, records = parse(s["baseline"])
    for row in s["rows"]:
        if row["source_xml"]:
            records[row["unid"]] = ET.fromstring(row["source_xml"])
    if unid not in records:
        raise Error("Объявление отсутствует в исходном файле.")
    if not removed:
        validate(draft)
    unchanged = draft == fields(records[unid])
    cur = conn.execute("UPDATE listing SET draft=?,removed=?,product_id=?,version=version+1 WHERE unid=? AND version=?", (None if unchanged or removed else json.dumps(draft, ensure_ascii=False), int(removed), product_id.strip(), unid, version))
    if cur.rowcount != 1:
        raise Error("Карточку уже изменил другой сотрудник. Обновите страницу.")
    conn.execute("UPDATE state SET revision=revision+1 WHERE id=1")
    audit(conn, uid, "edit", unid + (": снятие при следующей отправке" if removed else ": черновик сохранён"))


def set_removed(conn, unid, version, revision, removed, uid):
    """Mark or unmark one feed listing without requiring the edit form."""
    s = snapshot(conn)
    if not s["baseline"] or s["revision"] != revision:
        raise Error("Сверка изменилась. Обновите страницу.")
    cur = conn.execute(
        "UPDATE listing SET removed=?,version=version+1 WHERE unid=? AND version=?",
        (int(removed), unid, version),
    )
    if cur.rowcount != 1:
        raise Error("Карточку уже изменил другой сотрудник. Обновите страницу.")
    conn.execute("UPDATE state SET revision=revision+1 WHERE id=1")
    detail = ": подготовлено снятие" if removed else ": снятие отменено"
    audit(conn, uid, "removal", unid + detail)
    return ("Объявление подготовлено к снятию. Теперь проверьте список изменений и нажмите «Обновить файл на сервере»."
            if removed else "Снятие объявления отменено. Файл на сервере пока не изменялся.")


def publish(conn, revision, uid, remote_factory=Remote):
    s = snapshot(conn)
    if not s["baseline"] or s["revision"] != revision:
        raise Error("Сначала получите актуальный файл сервера и обновите страницу.")
    if not any(r["draft"] or r["removed"] or r["source_xml"] for r in s["rows"]):
        raise Error("Нет изменений для отправки.")
    data = build(s["baseline"], s["rows"])
    count = len(parse(data)[1])
    if s["manual_count"] is None:
        raise Error("Укажите актуальное количество ручных объявлений для проверки общего лимита 300.")
    if count + s["manual_count"] > LIMIT:
        raise Error("Общий лимит 300 превышен с учётом ручных объявлений.")
    if remote_factory is Remote:
        try:
            response = httpx.get(public_url(s["config"]["feed_url"]), timeout=20, follow_redirects=True)
            response.raise_for_status()
            if digest(response.content) != s["hash"]:
                raise Error("Публичная ссылка отдаёт другой файл. Проверьте адрес сайта и DNS перед отправкой.")
        except httpx.HTTPError as exc:
            raise Error("Файл пока недоступен по публичной ссылке сайта. Проверьте DNS и адрес XML; черновики сохранены.") from exc
    with remote_factory(s["config"]) as remote:
        baseline = remote.read(s["config"]["feed_path"])
        if digest(baseline) != s["hash"]:
            raise Error("Файл на хостинге изменён вне приложения. Отправка заблокирована; сохраните черновики и выполните сверку.")
        remote.publish(s["config"]["feed_path"], data, baseline)
    _, previous = parse(s["baseline"])
    for row in s["rows"]:
        if not row["removed"]:
            continue
        # Preserve the record even when it only existed as a local draft copy.
        node = previous.get(row["unid"])
        if node is None and row["source_xml"]:
            node = ET.fromstring(row["source_xml"])
        if node is None:
            continue
        conn.execute("INSERT INTO archive VALUES(?,?,?,?)", (row["unid"], now(), ET.tostring(node, encoding="utf-8"), row["product_id"]))
    conn.execute("DELETE FROM listing WHERE removed=1")
    conn.execute("UPDATE listing SET draft=NULL,source_xml=NULL,version=version+1")
    stamp = now()
    conn.execute("UPDATE state SET baseline=?,hash=?,synced_at=?,published_at=?,revision=revision+1 WHERE id=1", (data, digest(data), stamp, stamp))
    audit(conn, uid, "publish", f"Файл проверен: {digest(data)}")


def activate_full_candidate(conn, candidate_dir, revision, uid, remote_factory=Remote):
    """Replace the small working feed with the validated complete candidate."""
    s=snapshot(conn)
    if not s['baseline'] or s['revision']!=revision:
        raise Error('Данные изменились. Обновите страницу и заново проверьте полный файл.')
    if any(row['draft'] or row['removed'] or row['source_xml'] for row in s['rows']):
        raise Error('Сначала отправьте или отмените изменения текущего XML.')
    candidate_dir=Path(candidate_dir);xml_path=candidate_dir/'kufar-full-candidate.xml';report_path=candidate_dir/'report.json'
    if not xml_path.exists() or not report_path.exists():
        raise Error('Сначала соберите и проверьте полный файл-кандидат.')
    data=xml_path.read_bytes();report=json.loads(report_path.read_text(encoding='utf-8'))
    _,records=parse(data);mapping={row['unid']:row for row in report.get('mapping',[])}
    if report.get('category_blockers') or len(records)!=report.get('records') or set(records)!=set(mapping) or len(records)>LIMIT:
        raise Error('Полный файл-кандидат не прошёл контроль целостности.')
    if remote_factory is Remote:
        try:
            response=httpx.get(public_url(s['config']['feed_url']),timeout=20,follow_redirects=True)
            response.raise_for_status()
            if digest(response.content)!=s['hash']:
                raise Error('Публичная ссылка отдаёт другой файл. Выполните сверку перед заменой.')
        except httpx.HTTPError as exc:
            raise Error('Публичная ссылка XML недоступна. Полный файл не отправлен.') from exc
    with remote_factory(s['config']) as remote:
        baseline=remote.read(s['config']['feed_path'])
        if digest(baseline)!=s['hash']:
            raise Error('Файл на хостинге изменён вне приложения. Полный файл не отправлен.')
        remote.publish(s['config']['feed_path'],data,baseline)
    _,previous=parse(s['baseline'])
    stamp=now()
    for unid,node in previous.items():
        product_id=next((row['product_id'] for row in s['rows'] if row['unid']==unid),'')
        conn.execute('INSERT OR IGNORE INTO archive VALUES(?,?,?,?)',(unid,stamp,ET.tostring(node,encoding='utf-8'),product_id))
    conn.execute('DELETE FROM listing')
    conn.executemany('INSERT INTO listing(unid,product_id) VALUES(?,?)',
                     [(unid,mapping[unid].get('product_id','')) for unid in records])
    conn.execute('UPDATE state SET baseline=?,hash=?,synced_at=?,published_at=?,manual_count=0,manual_checked_at=?,revision=revision+1 WHERE id=1',
                 (data,digest(data),stamp,stamp,stamp))
    report['published']=True;report['published_at']=stamp;report['sha256']=digest(data)
    temp=report_path.with_suffix('.json.tmp');temp.write_text(json.dumps(report,ensure_ascii=False,indent=2),encoding='utf-8');temp.replace(report_path)
    audit(conn,uid,'activate-full-feed',f'Полный XML активирован: {len(records)} объявлений; {digest(data)}')
    return len(records)


def refresh_prices_and_stock(conn, revision, products, uid, remote_factory=Remote):
    """Update bound prices, archive bound products absent from active stock, then publish.

    The published file is always the complete current catalogue in one XML.
    Feed cards whose product left the active stock are removed from the file
    and their catalogue cards move to the archive with history preserved.
    """
    s=snapshot(conn)
    if not s['baseline'] or s['revision']!=revision:
        raise Error('Файл или карточки изменились. Обновите страницу и повторите.')
    _,records=parse(s['baseline']);updated=removed=unbound=0;removed_unids=[]
    for row in s['rows']:
        if not row['product_id']:
            unbound+=1;continue
        product=products.get(row['product_id'])
        if not product or not product.get('is_active') or product.get('site_price') is None:
            if not row['removed']:
                conn.execute('UPDATE listing SET removed=1,draft=NULL,version=version+1 WHERE unid=?',(row['unid'],));removed+=1;removed_unids.append(row['unid'])
            continue
        if row['removed']:
            continue
        node=ET.fromstring(row['source_xml']) if row['source_xml'] else records[row['unid']]
        draft=json.loads(row['draft']) if row['draft'] else fields(node)
        price=format(Decimal(str(product['site_price'])),'.2f')
        if draft['price']!=price:
            draft['price']=price
            conn.execute('UPDATE listing SET draft=?,version=version+1 WHERE unid=?',(json.dumps(draft,ensure_ascii=False),row['unid']));updated+=1
    if not updated and not removed:
        return dict(updated=0,removed=0,archived=0,unbound=unbound,published=False,total=len(s['rows']))
    conn.execute('UPDATE state SET revision=revision+1 WHERE id=1')
    new_revision=revision+1
    audit(conn,uid,'refresh-feed-prepare',f'Цены: {updated}; в архив без остатка: {removed}; без привязки: {unbound}')
    publish(conn,new_revision,uid,remote_factory)
    archived_inventory=0
    if removed_unids:
        from . import kufarstock
        kufarstock.schema(conn)
        for unid in removed_unids:
            if unid.startswith('KF'):
                archived_inventory+=conn.execute('UPDATE kufar_inventory SET archived=1,archived_at=?,local_removed=1,version=version+1 WHERE ad_id=? AND archived=0',
                                                 (now(),unid[2:])).rowcount
    return dict(updated=updated,removed=removed,archived=archived_inventory,unbound=unbound,published=True,total=len(snapshot(conn)['rows']))


def upload_photo(conn, revision, content, uid, remote_factory=Remote):
    s = snapshot(conn)
    if not s["baseline"] or s["revision"] != revision:
        raise Error("Сначала выполните сверку и обновите страницу.")
    if not content or len(content) > MAX_PHOTO:
        raise Error("Фотография должна быть размером до 15 МБ.")
    if content.startswith(b"\xff\xd8\xff"):
        ext = ".jpg"
    elif content.startswith(b"\x89PNG\r\n\x1a\n"):
        ext = ".png"
    elif content.startswith(b"RIFF") and content[8:12] == b"WEBP":
        ext = ".webp"
    else:
        raise Error("Загрузите фотографию JPEG, PNG или WebP.")
    name = uuid.uuid4().hex + ext
    with remote_factory(s["config"]) as remote:
        remote.write_verified(posixpath.join(s["config"]["photo_path"], name), content)
    url = s["config"]["photo_url"].rstrip("/") + "/" + name
    audit(conn, uid, "photo", url)
    return url


def create_listing(conn, revision, product_id, values, uid):
    s = snapshot(conn)
    if not s["baseline"] or s["revision"] != revision:
        raise Error("Сначала выполните сверку и обновите страницу.")
    unid = import_unid(product_id)
    if conn.execute("SELECT 1 FROM listing WHERE unid=? OR product_id=?", (unid, product_id)).fetchone():
        raise Error("Эта номенклатура уже есть в подготовке или файле импорта.")
    if s["manual_count"] is None or sum(not r["removed"] for r in s["rows"]) + s["manual_count"] >= LIMIT:
        raise Error("Укажите число ручных объявлений и проверьте доступность места в лимите 300.")
    category = categories().get(values.get("category"))
    if not category:
        raise Error("Выберите категорию Kufar.")
    body = values.get("body", "")
    if product_id not in body:
        body += "\n" + product_id
    body = with_standard_description(body, values.get("include_standard_text") == "1")
    draft = validate({"subject":values.get("subject", ""), "body":body, "price":values.get("price", "").replace(",", "."), "photos":[p.strip() for p in values.get("photos", "").splitlines() if p.strip()]})
    if not re.fullmatch(r"\+375(?:25|29|33|44|24)\d{7}", values.get("phone", "")):
        raise Error("Укажите телефон в формате +375XXXXXXXXX.")
    if not values.get("contact_person") or len(values["contact_person"]) > 50:
        raise Error("Укажите контактное имя до 50 символов.")
    # Initial seller is in Minsk; district must be selected explicitly.
    if values.get("area") not in {str(n) for n in range(22,31)}:
        raise Error("Выберите район Минска.")
    record = ET.Element("record")
    general = dict(unid=unid, region="7", area=values["area"], remuneration_type="1", subject=draft["subject"], body=draft["body"], category=values["category"], type="sell", phone=values["phone"], price=draft["price"], currency="BYN", contact_person=values["contact_person"])
    for field in category["fields"]:
        tag = field["tag"]
        value = values.get("parameter_" + tag, "").strip()
        allowed = {x[0] for x in field["options"]}
        if not value or (allowed and value not in allowed):
            raise Error("Заполните характеристику: " + field["label"])
        if tag not in general:
            general[tag] = value
    for tag, label in OPTIONAL_SHOP_FIELDS:
        value = values.get("parameter_" + tag, "").strip()
        if tag == "shop_guarantee" and not value:
            raise Error("Заполните характеристику: " + label + " (например, «1 месяц» или «Без гарантии»).")
        if value:
            if len(value) > 500:
                raise Error("Слишком длинное значение характеристики: " + label)
            general[tag] = value
    for tag,value in general.items():
        ET.SubElement(record,tag).text = value
    photos = ET.SubElement(record, "photos")
    for url in draft["photos"]:
        ET.SubElement(photos,"photo",{"picture":url})
    conn.execute("INSERT INTO listing(unid,product_id,source_xml) VALUES(?,?,?)", (unid, product_id, ET.tostring(record,encoding="utf-8")))
    conn.execute("UPDATE state SET revision=revision+1 WHERE id=1")
    audit(conn,uid,"create",product_id + ": новое объявление, локальный черновик")
