#!/usr/bin/env python3
# form-decompile v0.147 — Decompile 1C managed Form.xml to JSON DSL (draft)
# Source: https://github.com/Nikolay-Shirokov/cc-1c-skills
# ВНИМАНИЕ: раундтрип не гарантируется. Навык исключён из авто-использования моделью.
#
# Зеркало form-decompile.ps1 (канон). Структура 1:1 — те же имена функций, порядок,
# комментарии. Изменения вносить сначала в .ps1, затем переносить сюда строка-в-строку.
import argparse
import os
import re
import sys
import xml.etree.ElementTree as ET
from collections import OrderedDict
from decimal import Decimal

# --- 1. Namespaces ---
NS_LF = "http://v8.1c.ru/8.3/xcf/logform"
NS_V8 = "http://v8.1c.ru/8.1/data/core"
NS_XR = "http://v8.1c.ru/8.3/xcf/readable"
NS_XSI = "http://www.w3.org/2001/XMLSchema-instance"

NS_DCSSET = "http://v8.1c.ru/8.1/data-composition-system/settings"
NS_DCSSCH = "http://v8.1c.ru/8.1/data-composition-system/schema"
NS_DCSCOR = "http://v8.1c.ru/8.1/data-composition-system/core"
NS_V8UI = "http://v8.1c.ru/8.1/data/ui"
NS_APP = "http://v8.1c.ru/8.2/managed-application/core"

# Карта префиксов для ET.find/findall (зеркало XmlNamespaceManager).
NS = {
    'lf': NS_LF,
    'v8': NS_V8,
    'xr': NS_XR,
    'xsi': NS_XSI,
    'dcsset': NS_DCSSET,
    'dcssch': NS_DCSSCH,
    'dcscor': NS_DCSCOR,
    'v8ui': NS_V8UI,
    'app': NS_APP,
}

# Каноничные GUID пустых контейнеров ListSettings (умолчание платформы, ~90% форм).
# Если ListSettings = пустой скелет с этими GUID → декомпилятор опускает настройки вовсе,
# компилятор регенерит тот же скелет → чистый раундтрип.
CANON_FILTER_ID = 'dfcece9d-5077-440b-b6b3-45a5cb4538eb'
CANON_ORDER_ID = '88619765-ccb3-46c6-ac52-38e9c992ebd4'
CANON_CA_ID = 'b75fecce-942b-4aed-abc9-e6a02e460fb3'
CANON_ITEMS_ID = '911b6018-f537-43e8-a417-da56b22f9aec'

# Companion-элементы (авто-генерируемые компилятором) — пропускаем при обходе детей.
# Дополнения (Search*/ViewStatus) БОЛЬШЕ не companion — декомпилируются как тип-элементы
# (кастомные в AutoCommandBar/ChildItems → commandBar.children; стандартные на уровне таблицы → карта additions).
COMPANION_TAGS = ['ContextMenu', 'ExtendedTooltip', 'AutoCommandBar']

# Скрипт-скоуп состояние (зеркало $script:* канона). ROOT/NS_DOC ставятся в main().
ROOT = None
NSMAP_DOC = {}
OUTPUT_DIR = None
OUTPUT_BASENAME = None
QUERY_FILES_ACCUMULATOR = []
QUERY_FILE_NAMES_USED = {}

# Атрибут с пространством имён в формате ET ({uri}local) — зеркало GetAttribute("x", $NS_XSI).
_XSI_TYPE = '{%s}type' % NS_XSI


def _attr(node, name, ns_uri=None):
    """GetAttribute(name[, ns]) — .NET возвращает "" для отсутствующего атрибута, ET → None."""
    if node is None:
        return ''
    key = ('{%s}%s' % (ns_uri, name)) if ns_uri else name
    v = node.get(key)
    return v if v is not None else ''


# ═══════════════════════════════════════════════════════════════════════════
# JSON-сериализатор — точное зеркало ConvertTo-CompactJson/Try-InlineJson/
# Convert-StringToJsonLiteral. json.dumps НЕ подходит (иная раскладка inline/
# multiline и эскейпинг). Кириллица в выводе сырая (UTF-8 без эскейпа).
# ═══════════════════════════════════════════════════════════════════════════

def convert_string_to_json_literal(s):
    if s is None:
        return 'null'
    sb = ['"']
    for ch in s:
        code = ord(ch)
        if code == 0x22:
            sb.append('\\"')
        elif code == 0x5C:
            sb.append('\\\\')
        elif code == 0x08:
            sb.append('\\b')
        elif code == 0x09:
            sb.append('\\t')
        elif code == 0x0A:
            sb.append('\\n')
        elif code == 0x0C:
            sb.append('\\f')
        elif code == 0x0D:
            sb.append('\\r')
        elif code < 0x20:
            sb.append('\\u%04x' % code)
        else:
            sb.append(ch)
    sb.append('"')
    return ''.join(sb)


def _num_to_str(obj):
    """Зеркало [System.Convert]::ToString(.., InvariantCulture)."""
    if isinstance(obj, bool):
        return 'true' if obj else 'false'
    if isinstance(obj, int):
        return str(obj)
    # Decimal — зеркало [decimal].ToString(): сохраняет масштаб ("1.50" остаётся "1.50").
    if isinstance(obj, Decimal):
        return str(obj)
    # float — зеркало [double].ToString('R'/InvariantCulture): кратчайшее round-trip, без хвостового .0.
    r = repr(float(obj))
    if r.endswith('.0'):
        r = r[:-2]
    return r


def try_inline_json(obj):
    if obj is None:
        return 'null'
    if isinstance(obj, bool):
        return 'true' if obj else 'false'
    if isinstance(obj, str):
        return convert_string_to_json_literal(obj)
    if isinstance(obj, (int, float, Decimal)):
        return _num_to_str(obj)
    if isinstance(obj, dict):
        if len(obj) == 0:
            return '{}'
        parts = []
        for k in obj.keys():
            v = try_inline_json(obj[k])
            if v is None:
                return None
            parts.append('%s: %s' % (convert_string_to_json_literal(str(k)), v))
        return '{ ' + ', '.join(parts) + ' }'
    if isinstance(obj, (list, tuple)):
        items = list(obj)
        if len(items) == 0:
            return '[]'
        parts = []
        for it in items:
            v = try_inline_json(it)
            if v is None:
                return None
            parts.append(v)
        return '[' + ', '.join(parts) + ']'
    return None


def convert_to_compact_json(obj, depth=0, indent_unit='  ', line_limit=120):
    indent = indent_unit * depth
    child_indent = indent_unit * (depth + 1)
    if obj is None:
        return 'null'
    if isinstance(obj, bool):
        return 'true' if obj else 'false'
    if isinstance(obj, str):
        return convert_string_to_json_literal(obj)
    if isinstance(obj, (int, float, Decimal)):
        return _num_to_str(obj)
    is_container = isinstance(obj, (dict, list, tuple))
    if is_container:
        inline_attempt = try_inline_json(obj)
        if inline_attempt is not None and (len(indent) + len(inline_attempt)) <= line_limit:
            return inline_attempt
    if isinstance(obj, dict):
        keys = list(obj.keys())
        if len(keys) == 0:
            return '{}'
        parts = []
        for k in keys:
            val = convert_to_compact_json(obj[k], depth + 1, indent_unit, line_limit)
            parts.append('%s%s: %s' % (child_indent, convert_string_to_json_literal(str(k)), val))
        return '{\n' + ',\n'.join(parts) + '\n' + indent + '}'
    if isinstance(obj, (list, tuple)):
        items = list(obj)
        if len(items) == 0:
            return '[]'
        parts = ['%s%s' % (child_indent, convert_to_compact_json(it, depth + 1, indent_unit, line_limit)) for it in items]
        return '[\n' + ',\n'.join(parts) + '\n' + indent + ']'
    return convert_string_to_json_literal(str(obj))


# ═══════════════════════════════════════════════════════════════════════════
# Низкоуровневые читатели текста.
# .NET .InnerText = конкатенация текста всех потомков. PreserveWhitespace=false
# в каноне сворачивает whitespace-only текст-узлы в "". ET не имеет такого режима,
# поэтому два читателя на одном ws-сохраняющем дереве:
#   _text     — main-doc семантика (whitespace-only → ""), для всех чтений значений;
#   _text_ws  — сырой текст (для Resolve-WS: восстановление точного числа пробелов).
# ═══════════════════════════════════════════════════════════════════════════

def _text(node):
    if node is None:
        return None
    s = ''.join(node.itertext())
    if s != '' and s.strip() == '':
        return ''
    return s


def _text_ws(node):
    if node is None:
        return None
    return ''.join(node.itertext())


# Запрос ≥3 строк + есть outputDir → вынести в `<basename>-<listName>.sql`, вернуть "@file".
def maybe_externalize_query(query_text, list_name):
    if not query_text:
        return query_text
    if not OUTPUT_DIR:
        return query_text
    line_count = len(re.findall('\n', query_text)) + 1
    if line_count < 3:
        return query_text
    safe = re.sub(r'[^\w\-]', '_', list_name)
    if not safe:
        safe = 'query'
    prefix = (OUTPUT_BASENAME + '-') if OUTPUT_BASENAME else ''
    file_name = prefix + safe + '.sql'
    suffix = 1
    while file_name in QUERY_FILE_NAMES_USED:
        suffix += 1
        file_name = '%s%s_%d.sql' % (prefix, safe, suffix)
    QUERY_FILE_NAMES_USED[file_name] = True
    QUERY_FILES_ACCUMULATOR.append(OrderedDict([('fileName', file_name), ('text', query_text)]))
    return '@' + file_name


def save_query_files():
    if len(QUERY_FILES_ACCUMULATOR) == 0:
        return
    if not OUTPUT_DIR:
        return
    for qf in QUERY_FILES_ACCUMULATOR:
        with open(os.path.join(OUTPUT_DIR, qf['fileName']), 'w', encoding='utf-8', newline='') as f:
            f.write(qf['text'])
    sys.stderr.write("Saved %d external query file(s)\n" % len(QUERY_FILES_ACCUMULATOR))


# Есть ли в ListSettings содержательные настройки (реальные items фильтра/порядка/
# условного оформления/параметров)? Пустой скелет (только viewMode+GUID) → false.
def test_list_settings_has_content(ls_node):
    if ls_node is None:
        return False
    for cont in ('filter', 'order', 'conditionalAppearance', 'dataParameters'):
        cn = ls_node.find('dcsset:%s' % cont, NS)
        if cn is not None and cn.find('dcsset:item', NS) is not None:
            return True
    return False


# Форма ListSettings: ordered-карта present top-level элементов. $null, если форма ==
# полному каноничному скелету ИЛИ содержит неподдержанные top-level элементы → канон-fallback.
def get_list_settings_shape(ls_node, has_grouping=False):
    if ls_node is None:
        return None
    shape = OrderedDict()
    for child in list(ls_node):
        tag = _local_name(child.tag)
        if tag in ('filter', 'order', 'conditionalAppearance'):
            has_vm = child.find('dcsset:viewMode', NS) is not None
            has_us = child.find('dcsset:userSettingID', NS) is not None
            code = ('v' if has_vm else '') + ('u' if has_us else '')
            usp_node = child.find('dcsset:userSettingPresentation', NS)
            if usp_node is not None:
                usp = get_pres_by_type(usp_node)
                shape[tag] = OrderedDict([('meta', code), ('presentation', usp)])
            else:
                shape[tag] = code
        elif tag == 'itemsViewMode':
            shape['itemsViewMode'] = True
        elif tag == 'itemsUserSettingID':
            shape['itemsUserSettingID'] = True
        elif tag == 'itemsUserSettingPresentation':
            shape['itemsUserSettingPresentation'] = get_pres_by_type(child)
        elif tag == 'dataParameters':
            shape['dataParameters'] = True
        elif tag == 'item':
            if has_grouping:
                shape['structure'] = True
            else:
                return None
        else:
            return None
    if (len(shape) == 5 and shape.get('filter') == 'vu' and shape.get('order') == 'vu'
            and shape.get('conditionalAppearance') == 'vu' and shape.get('itemsViewMode') is True
            and shape.get('itemsUserSettingID') is True):
        return None
    return shape


# Группировка строк динамического списка: цепочка <dcsset:item StructureItemGroup>.
# Плоский массив уровней ИЛИ $null (не «чистая линейная цепочка одно-польных уровней»).
def build_group_level(fn):
    field = get_child(fn, 'field')
    gt = get_child(fn, 'groupType')
    pat = get_child(fn, 'periodAdditionType')
    pab_n = fn.find('dcsset:periodAdditionBegin', NS)
    pae_n = fn.find('dcsset:periodAdditionEnd', NS)
    pab = None
    pae = None
    if pab_n is not None:
        pt = _attr(pab_n, 'type', NS_XSI)
        pv = _text(pab_n)
        if re.search(r'Field$', pt) or (pv and pv != '0001-01-01T00:00:00'):
            pab = pv
    if pae_n is not None:
        pt = _attr(pae_n, 'type', NS_XSI)
        pv = _text(pae_n)
        if re.search(r'Field$', pt) or (pv and pv != '0001-01-01T00:00:00'):
            pae = pv
    is_default = ((not gt) or gt == 'Items') and ((not pat) or pat == 'None') and (not pab) and (not pae)
    if is_default:
        return field
    o = OrderedDict([('field', field)])
    if gt and gt != 'Items':
        o['groupType'] = gt
    if pat and pat != 'None':
        o['periodAdditionType'] = pat
    if pab:
        o['periodAdditionBegin'] = pab
    if pae:
        o['periodAdditionEnd'] = pae
    return o


def build_list_grouping(item_node):
    levels = []
    cur = item_node
    while cur is not None:
        if not re.search(r'StructureItemGroup$', _attr(cur, 'type', NS_XSI)):
            return None
        gi = None
        nested = []
        for ch in list(cur):
            ln = _local_name(ch.tag)
            if ln == 'groupItems':
                if gi is not None:
                    return None
                gi = ch
            elif ln == 'item':
                nested.append(ch)
            else:
                return None
        if gi is None:
            return None
        field_items = gi.findall('dcsset:item', NS)
        if len(field_items) != 1:
            return None
        fn = field_items[0]
        if not re.search(r'GroupItemField$', _attr(fn, 'type', NS_XSI)):
            return None
        levels.append(build_group_level(fn))
        if len(nested) == 0:
            break
        if len(nested) > 1:
            return None
        cur = nested[0]
    if len(levels) == 0:
        return None
    return levels


# Ring-3: конструкции вне зоны поддержки → stderr + exit 3 (см. ring3-скан в main).
def fail_ring3(kind, loc):
    sys.stderr.write("form-decompile: декомпиляция пока не поддерживает %s (path: %s)\n" % (kind, loc))
    sys.stderr.write("Для точечной работы с этой формой используй /form-edit.\n")
    sys.exit(3)


# Извлечь мультиязычный Title/Presentation → string (ru) или ordered hash {ru,en,...}
def get_lang_text(node):
    if node is None:
        return None
    items = node.findall('v8:item', NS)
    if len(items) == 0:
        return None
    m = OrderedDict()
    for it in items:
        lang = it.find('v8:lang', NS)
        content = it.find('v8:content', NS)
        if lang is not None:
            m[_text(lang)] = _text(content) if content is not None else ""
    if len(m) == 1 and 'ru' in m:
        return m['ru']
    return m


# Точное число пробелов whitespace-only <v8:content>: ET хранит .text дословно,
# второй WS-парс не нужен — читаем сырой текст того же узла (_text_ws).
def resolve_ws(content_node):
    if content_node is None:
        return None
    return _text_ws(content_node)


# Точное восстановление пробела: whitespace-only content → реальная строка пробелов.
def restore_ws_content(content_node):
    ws = resolve_ws(content_node)
    if ws and ws.strip() == '':
        return ws
    return ' '


def get_lang_text_ws(node):
    t = get_lang_text(node)
    if t is None:
        return None
    if isinstance(t, str):
        cn = node.find('v8:item/v8:content', NS)
        if t == '' and cn is not None:
            return restore_ws_content(cn)
        return t
    for it in node.findall('v8:item', NS):
        lang = it.find('v8:lang', NS)
        content = it.find('v8:content', NS)
        if lang is not None and content is not None:
            lt = _text(lang)
            if lt in t and t[lt] == '':
                t[lt] = restore_ws_content(content)
    return t


# Авто-вывод заголовка из имени — ТОЧНОЕ зеркало Title-FromName из form-compile.
def title_from_name(name):
    if not name:
        return ''
    s = re.sub(r'([А-ЯA-Z])([А-ЯA-Z][а-яa-z])', r'\1 \2', name)
    s = re.sub(r'([а-яa-z0-9])([А-ЯA-Z])', r'\1 \2', s)
    parts = s.split(' ')
    if len(parts) == 0:
        return s
    out = [parts[0]]
    for i in range(1, len(parts)):
        p = parts[i]
        if len(p) > 1 and p == p.upper():
            out.append(p)
        else:
            out.append(p.lower())
    return ' '.join(out)


# Детектор «настоящей» inline-разметки форматированного текста (идентичен form-compile!).
FMT_MARKUP_RE = r'</>|<\s*(?:link|b|i|u|s|color|colorStyle|bgColor|bgColorStyle|font|fontSize|fontStyle|img)(?:\s|>)'


def test_has_real_markup(text):
    if text is None:
        return False
    vals = list(text.values()) if isinstance(text, dict) else [str(text)]
    for v in vals:
        if re.search(FMT_MARKUP_RE, str(v)):
            return True
    return False


# Title-узел → DSL-значение ML-поля (гибрид): строка/мапа или явный {text, formatted}.
def get_ml_formatted_value(title_node):
    if title_node is None:
        return None
    text = get_lang_text_ws(title_node)
    if text is None:
        return None
    fmt_attr = (_attr(title_node, 'formatted') == 'true')
    if fmt_attr == test_has_real_markup(text):
        return text
    o = OrderedDict()
    o['text'] = text
    o['formatted'] = fmt_attr
    return o


# Прочитать дочерний скаляр (по local-name, без namespace)
def get_child(node, name):
    if node is None:
        return None
    c = node.find('{*}%s' % name)
    if c is not None:
        return _text(c)
    return None


def has_child(node, name):
    if node is None:
        return False
    return node.find('{*}%s' % name) is not None


def to_bool(v):
    return v == 'true'


# Значение с учётом xsi:type → нативный JSON-тип (число/булево/строка).
def convert_typed_value(raw, xsi_type):
    if re.search(r'decimal$', xsi_type):
        if re.match(r'^-?\d+$', raw):
            return int(raw)
        return float(raw)
    if re.search(r'boolean$', xsi_type):
        return raw == 'true'
    return raw


# Прочитать дочерний скаляр по xpath (с NS). Аналог skd Get-Text.
def get_text(node, xpath):
    if node is None:
        return None
    if xpath is None or xpath == '':
        return _text(node)
    n = node.find(xpath, NS)
    if n is not None:
        return _text(n)
    return None


# Мультиязычный текст (LocalStringType) → string (ru) или ordered hash. Алиас Get-LangText.
def get_ml_text(node):
    return get_lang_text(node)


# Презентация: либо мультиязычный LocalStringType, либо плоский xs:string.
def get_pres_text(node):
    if node is None:
        return None
    ml = get_ml_text(node)
    if ml is not None:
        return ml
    t = _text(node)
    if t:
        return t
    return None


# Presentation, сохраняющий ФОРМУ по xsi:type (ru-only LocalStringType ≠ xs:string).
def get_pres_by_type(node):
    if node is None:
        return None
    xt = _attr(node, 'type', NS_XSI)
    if re.search(r'LocalStringType$', xt):
        d = OrderedDict()
        for it in node.findall('v8:item', NS):
            lang = get_text(it, 'v8:lang')
            content = get_text(it, 'v8:content')
            if lang:
                d[lang] = content
        if len(d) > 0:
            return d
        return None
    t = _text(node)
    if t:
        return t
    return None


# Снять namespace-префикс с xsi:type ("dcsset:Foo" → "Foo")
def get_local_xsi_type(node):
    if node is None:
        return None
    t = _attr(node, 'type', NS_XSI)
    mt = re.search(r':(.+)$', t)
    if mt:
        return mt.group(1)
    return t


# Зеркало булевой коэрции PowerShell `if ($x)`: одноэлементный массив коэрсится в truthiness
# СВОЕГО элемента (а не «непустой список → true», как в Python). Нужно там, где канон пишет
# `if ($arr)` на результате билдера: напр. вырожденный FunctionalOptions @("") → falsy → дроп.
def _ps_truthy(v):
    if v is None:
        return False
    if isinstance(v, bool):
        return v
    if isinstance(v, str):
        return v != ''
    if isinstance(v, (int, float)):
        return v != 0
    if isinstance(v, dict):
        return True   # Hashtable/[ordered] — объект, всегда truthy
    if isinstance(v, (list, tuple)):
        if len(v) == 0:
            return False
        if len(v) == 1:
            return _ps_truthy(v[0])
        return True
    return True


# Зеркало PowerShell -eq/-ne для строк: регистронезависимое сравнение (PS по умолчанию ignore-case).
# Нужно там, где сравниваются произвольно-регистровые строки (заголовок vs авто-вывод из имени).
def _ps_ieq(a, b):
    return a.lower() == b.lower()


# Зеркало PowerShell "$v" (строковая интерполяция): bool→True/False, float без хвостового .0,
# $null→'', иначе str(). Используется везде, где канон делает "$value".
def _ps_str(v):
    if isinstance(v, bool):
        return 'True' if v else 'False'
    if isinstance(v, (float, Decimal)):
        return _num_to_str(v)
    if v is None:
        return ''
    return str(v)


# Шрифт оформления → объект {@type:Font, ...} (bit-perfect для compile).
def get_font_value(val_node):
    f = OrderedDict([('@type', 'Font')])
    for attr_name in ('ref', 'faceName', 'height', 'bold', 'italic', 'underline', 'strikeout', 'kind', 'scale'):
        a = val_node.get(attr_name)
        if a is not None:
            f[attr_name] = a
    return f


# Линия (граница) оформления → объект {@type:Line, width, gap, style}.
def get_line_value(val_node):
    obj = OrderedDict([('@type', 'Line')])
    w = _attr(val_node, 'width')
    g = _attr(val_node, 'gap')
    if w != '':
        obj['width'] = int(w) if re.match(r'^-?\d+$', w) else w
    if g != '':
        obj['gap'] = (g == 'true')
    style_node = val_node.find('v8ui:style', NS)
    if style_node is not None:
        obj['style'] = _text(style_node)
    return obj


# Прочитать <dcscor:value> в JSON-значение: Font/Line/Field/multilang/raw text.
def read_appearance_value_node(val_node):
    if val_node is None:
        return None
    vt = get_local_xsi_type(val_node)
    if vt == 'LocalStringType':
        # НЕ схлопываем одноязычный в строку: значение параметра оформления различает
        # xs:string (плоская строка) и LocalStringType (локализуемый текст).
        m = OrderedDict()
        for it in val_node.findall('v8:item', NS):
            lang = it.find('v8:lang', NS)
            content = it.find('v8:content', NS)
            if lang is not None:
                m[_text(lang)] = _text(content) if content is not None else ""
        return m
    if vt == 'Font':
        return get_font_value(val_node)
    if vt == 'Line':
        return get_line_value(val_node)
    if vt == 'Field':
        return OrderedDict([('field', _text(val_node))])
    return _text(val_node)


# Обратная карта comparisonType → короткий оператор фильтра (зеркало skd).
FILTER_OP_MAP = {
    'Equal': '=', 'NotEqual': '<>', 'Greater': '>', 'GreaterOrEqual': '>=',
    'Less': '<', 'LessOrEqual': '<=', 'InList': 'in', 'NotInList': 'notIn',
    'InHierarchy': 'inHierarchy', 'InListByHierarchy': 'inListByHierarchy',
    'Contains': 'contains', 'NotContains': 'notContains',
    'BeginsWith': 'beginsWith', 'NotBeginsWith': 'notBeginsWith',
    'Like': 'like', 'NotLike': 'notLike',
    'Filled': 'filled', 'NotFilled': 'notFilled',
}

# Авто-детект DTV-ссылки (Перечисление.X/Catalog.X/…): компилятор сам выводит DesignTimeValue
# для таких значений → не фиксируем явный valueType. Инлайн в каноне (дважды) — держим как константу.
_DTV_REF_RE = r'^(Перечисление|Справочник|ПланСчетов|Документ|ПланВидовХарактеристик|ПланВидовРасчета|БизнесПроцесс|Задача|РегистрСведений|ПланОбмена|Catalog|Enum|Document|ChartOfAccounts|ChartOfCharacteristicTypes|ChartOfCalculationTypes|BusinessProcess|Task|InformationRegister|ExchangePlan)\.'


# Render filter value node → shorthand-acceptable scalar string
def get_filter_value(val_node):
    if val_node is None:
        return '_'
    nil = _attr(val_node, 'nil', NS_XSI)
    if nil == 'true':
        return '_'
    v_type = get_local_xsi_type(val_node)
    if v_type == 'DesignTimeValue':
        return _text(val_node)
    if v_type == 'LocalStringType':
        return get_ml_text(val_node)
    txt = _text(val_node)
    if not txt:
        return '_'
    return txt


# Get-FilterValue + xsi:type значения (для valueType, например dcscor:Field).
def get_filter_value_with_type(val_node):
    if val_node is None:
        return {'value': '_', 'type': None}
    raw_type = _attr(val_node, 'type', NS_XSI)
    nil = _attr(val_node, 'nil', NS_XSI)
    if nil == 'true':
        return {'value': '_', 'type': None}
    v_type = get_local_xsi_type(val_node)
    if v_type == 'LocalStringType':
        return {'value': get_ml_text(val_node), 'type': raw_type}
    # Стандартная дата начала/окончания: SBD Custom+date → голая ISO-дата без valueType;
    # именованный вариант → строка + valueType; SED Custom/нетипичное → {variant, date} + valueType.
    if v_type == 'StandardBeginningDate' or v_type == 'StandardEndDate':
        variant_n = val_node.find('v8:variant', NS)
        date_n = val_node.find('v8:date', NS)
        variant_str = _text(variant_n) if variant_n is not None else ''
        if date_n is not None:
            if v_type == 'StandardBeginningDate' and variant_str == 'Custom':
                return {'value': _text(date_n), 'type': None}
            return {'value': OrderedDict([('variant', variant_str), ('date', _text(date_n))]), 'type': raw_type}
        return {'value': variant_str, 'type': raw_type}
    txt = _text(val_node)
    if not txt:
        return {'value': '_', 'type': raw_type}
    if v_type == 'boolean':
        return {'value': (txt == 'true'), 'type': raw_type}
    if v_type == 'decimal':
        if re.match(r'^-?\d+$', txt):
            return {'value': int(txt), 'type': raw_type}
        return {'value': float(txt), 'type': raw_type}
    return {'value': txt, 'type': raw_type}


# Convert filter item node → shorthand string или object form (рекурсивно для групп).
def build_filter_item(item_node, loc):
    xtype = get_local_xsi_type(item_node)
    if xtype == 'FilterItemGroup':
        gt = get_text(item_node, 'dcsset:groupType')
        group_name = {'OrGroup': 'Or', 'NotGroup': 'Not'}.get(gt, 'And')
        items = []
        for c in item_node.findall('dcsset:item', NS):
            bi = build_filter_item(c, '%s/item' % loc)
            if bi is not None:
                items.append(bi)
        g_obj = OrderedDict([('group', group_name), ('items', items)])
        if get_text(item_node, 'dcsset:use') == 'false':
            g_obj['use'] = False   # группа отключена (@off)
        g_pres_node = item_node.find('dcsset:presentation', NS)
        if g_pres_node is not None:
            g_pres = get_pres_by_type(g_pres_node)
            if g_pres is not None and g_pres != '':
                g_obj['presentation'] = g_pres
        g_vm_node = item_node.find('dcsset:viewMode', NS)
        if g_vm_node is not None:
            g_obj['viewMode'] = _text(g_vm_node)
        g_usid = get_text(item_node, 'dcsset:userSettingID')
        if g_usid:
            g_obj['userSettingID'] = 'auto'
        g_uspn = item_node.find('dcsset:userSettingPresentation', NS)
        if g_uspn is not None:
            g_usp = get_pres_text(g_uspn)
            if g_usp:
                g_obj['userSettingPresentation'] = g_usp
        return g_obj
    if xtype != 'FilterItemComparison':
        sys.stderr.write("form-decompile: пропущен фильтр неизвестного типа '%s' (path: %s)\n" % (xtype, loc))
        return None
    left_node = item_node.find('dcsset:left', NS)
    field = _text(left_node) if left_node is not None else None
    ct = get_text(item_node, 'dcsset:comparisonType')
    op = FILTER_OP_MAP.get(ct)
    if not op:
        op = ct

    right_nodes = item_node.findall('dcsset:right', NS)
    value = None
    value_is_array_flag = False
    value_type_attr = None
    if len(right_nodes) == 1:
        rn = right_nodes[0]
        if get_local_xsi_type(rn) == 'ValueListType':
            value = []
            value_is_array_flag = True
        else:
            vt = get_filter_value_with_type(rn)
            value = vt['value']
            auto_detects_dtv = (vt['type'] == 'dcscor:DesignTimeValue') and \
                bool(re.search(_DTV_REF_RE, _ps_str(vt['value'])))
            if vt['type'] and not re.match(r'^xs:', vt['type']) and not auto_detects_dtv:
                value_type_attr = vt['type']
            elif vt['type'] == 'xs:string' and isinstance(value, str) and re.search(r'^(-?\d+(\.\d+)?|\d{4}-\d{2}-\d{2}T)', value):
                # Значение-строка "1"/"2020-..." с xs:string: компилятор авто-детектит число/дату → фиксируем явный valueType.
                value_type_attr = 'xs:string'
    elif len(right_nodes) > 1:
        arr = []
        raw_types = []
        for rn in right_nodes:
            arr.append(get_filter_value(rn))
            raw_types.append(_attr(rn, 'type', NS_XSI))
        value = arr
        value_is_array_flag = True
        uniq_types = sorted(set(raw_types))
        if len(uniq_types) == 1 and uniq_types[0]:
            auto_detects_dtv = (uniq_types[0] == 'dcscor:DesignTimeValue') and \
                (len(arr) > 0) and \
                (len([x for x in arr if not re.search(_DTV_REF_RE, _ps_str(x))]) == 0)
            if not auto_detects_dtv:
                value_type_attr = uniq_types[0]

    use = get_text(item_node, 'dcsset:use')
    user_id = get_text(item_node, 'dcsset:userSettingID')
    vm_node = item_node.find('dcsset:viewMode', NS)
    view_mode = _text(vm_node) if vm_node is not None else None
    user_pres_node = item_node.find('dcsset:userSettingPresentation', NS)
    fi_pres_node = item_node.find('dcsset:presentation', NS)
    fi_pres = None
    if fi_pres_node is not None:
        fi_pres = get_pres_by_type(fi_pres_node)

    flags = []
    if use == 'false':
        flags.append('@off')
    if user_id:
        flags.append('@user')
    if view_mode == 'QuickAccess':
        flags.append('@quickAccess')
    elif view_mode == 'Inaccessible':
        flags.append('@inaccessible')
    elif view_mode == 'Normal':
        flags.append('@normal')

    no_value_ops = ('filled', 'notFilled')

    # Пустой xs:string right ≠ отсутствие <right>; пробельные значения рвут shorthand → форсим объект.
    val_needs_obj = False
    if len(right_nodes) == 1 and not value_is_array_flag and op not in no_value_ops:
        if _ps_str(value) == '_':
            ws = resolve_ws(right_nodes[0])
            if ws and len(ws) > 0 and ws.strip() == '':
                value = ws
            val_needs_obj = True
        elif value is not None and re.search(r'\s', _ps_str(value)):
            val_needs_obj = True

    if user_pres_node is not None or value_is_array_flag or value_type_attr or fi_pres or val_needs_obj:
        obj = OrderedDict([('field', field), ('op', op)])
        if op not in no_value_ops and value is not None:
            if value_is_array_flag:
                arr_as_list = []
                for vv in (value if isinstance(value, (list, tuple)) else [value]):
                    arr_as_list.append(vv)
                obj['value'] = arr_as_list
            else:
                obj['value'] = value
        if value_type_attr:
            obj['valueType'] = value_type_attr
        if use == 'false':
            obj['use'] = False
        if user_id:
            obj['userSettingID'] = 'auto'
        if fi_pres:
            obj['presentation'] = fi_pres
        if view_mode:
            obj['viewMode'] = view_mode
        if user_pres_node is not None:
            obj['userSettingPresentation'] = get_pres_text(user_pres_node)
        return obj

    s = field if field is not None else ''   # $null + строка в PS → '' (избегаем TypeError)
    if op in no_value_ops:
        s += ' ' + op
    else:
        v_display = '_'
        if value is not None:
            if isinstance(value, bool):
                v_display = 'true' if value else 'false'
            elif _ps_str(value) != '':
                v_display = _ps_str(value)
        s += ' ' + op + ' ' + v_display
    if flags:
        s += ' ' + ' '.join(flags)
    return s


# Рекурсивный хелпер одного элемента selection (для conditionalAppearance).
def build_selection_item(item, loc):
    xt = get_local_xsi_type(item)
    if not xt:
        f_name = get_text(item, 'dcsset:field')
        if f_name:
            return f_name
        field_el = item.find('dcsset:field', NS)
        if field_el is not None:
            return 'Auto'
    if xt == 'SelectedItemAuto':
        use_v = get_text(item, 'dcsset:use')
        if use_v == 'false':
            return OrderedDict([('auto', True), ('use', False)])
        return 'Auto'
    if xt == 'SelectedItemField':
        f_name = get_text(item, 'dcsset:field')
        title_node = item.find('dcsset:lwsTitle', NS)
        title = get_ml_text(title_node)
        vm_n = item.find('dcsset:viewMode', NS)
        use_v = get_text(item, 'dcsset:use')
        use_false = (use_v == 'false')
        if title or vm_n is not None or use_false:
            obj = OrderedDict([('field', f_name)])
            if use_false:
                obj['use'] = False
            if title:
                obj['title'] = title
            if vm_n is not None:
                obj['viewMode'] = _text(vm_n)
            return obj
        return f_name
    if xt == 'SelectedItemFolder':
        title_node = item.find('dcsset:lwsTitle', NS)
        folder_title = get_ml_text(title_node)
        inner = []
        for sub in item.findall('dcsset:item', NS):
            bi = build_selection_item(sub, '%s/folder' % loc)
            if bi is not None:
                inner.append(bi)
        entry = OrderedDict([('folder', folder_title), ('items', inner)])
        folder_field = get_text(item, 'dcsset:field')
        if folder_field:
            entry['field'] = folder_field
        pl_n = item.find('dcsset:placement', NS)
        if pl_n is not None and _text(pl_n) and _text(pl_n) != 'Auto':
            entry['placement'] = _text(pl_n)
        return entry
    sys.stderr.write("form-decompile: пропущен элемент selection неизвестного типа '%s' (path: %s)\n" % (xt, loc))
    return None


# Build selection items array (для conditionalAppearance).
def build_selection(sel_node, loc):
    if sel_node is None:
        return []
    out = []
    for it in sel_node.findall('dcsset:item', NS):
        bi = build_selection_item(it, loc)
        if bi is not None:
            out.append(bi)
    return out


# Build order items array.
def build_order(ord_node, loc):
    if ord_node is None:
        return []
    out = []
    for it in ord_node.findall('dcsset:item', NS):
        xt = get_local_xsi_type(it)
        if xt == 'OrderItemAuto':
            out.append('Auto')
        elif xt == 'OrderItemField':
            fn = get_text(it, 'dcsset:field')
            ot = get_text(it, 'dcsset:orderType')
            vm_n = it.find('dcsset:viewMode', NS)
            use_v = get_text(it, 'dcsset:use')
            use_false = (use_v == 'false')
            if vm_n is not None or use_false:
                obj = OrderedDict([('field', fn)])
                if use_false:
                    obj['use'] = False
                if ot == 'Desc':
                    obj['direction'] = 'desc'
                if vm_n is not None:
                    obj['viewMode'] = _text(vm_n)
                out.append(obj)
            else:
                if ot == 'Desc':
                    out.append('%s desc' % fn)
                else:
                    out.append(fn)
        else:
            sys.stderr.write("form-decompile: пропущен элемент сортировки неизвестного типа '%s' (path: %s)\n" % (xt, loc))
    return out


# Build appearance dict из <dcsset:appearance> (Line/Font/multilang/nested items).
def get_settings_appearance(app_node):
    if app_node is None:
        return None
    d = OrderedDict()
    for it in app_node.findall('dcscor:item', NS):
        p_name = get_text(it, 'dcscor:parameter')
        val = it.find('dcscor:value', NS)
        if not p_name or val is None:
            continue
        raw_val = read_appearance_value_node(val)
        use_v = get_text(it, 'dcscor:use')
        nested_items = OrderedDict()
        for sub in it.findall('dcscor:item', NS):
            sub_name = get_text(sub, 'dcscor:parameter')
            sub_val = sub.find('dcscor:value', NS)
            if not sub_name:
                continue
            sub_raw = read_appearance_value_node(sub_val)
            sub_use = get_text(sub, 'dcscor:use')
            sub_entry = OrderedDict([('value', sub_raw)])
            if sub_use == 'false':
                sub_entry['use'] = False
            nested_items[sub_name] = sub_entry
        val_is_line = isinstance(raw_val, dict) and ('@type' in raw_val) and (raw_val['@type'] == 'Line')
        if val_is_line:
            if use_v == 'false':
                raw_val['use'] = False
            if len(nested_items) > 0:
                raw_val['items'] = nested_items
            d[p_name] = raw_val
        elif (use_v == 'false') or (len(nested_items) > 0):
            wrap = OrderedDict([('value', raw_val)])
            if use_v == 'false':
                wrap['use'] = False
            if len(nested_items) > 0:
                wrap['items'] = nested_items
            d[p_name] = wrap
        else:
            d[p_name] = raw_val
    return d


# Build conditionalAppearance array.
def build_conditional_appearance(ca_node, loc):
    if ca_node is None:
        return []
    out = []
    i = 0
    for it in ca_node.findall('dcsset:item', NS):
        entry = OrderedDict()
        scope_node = it.find('dcsset:scope', NS)
        if scope_node is not None and (len(scope_node) > 0 or bool(_text(scope_node))):
            sys.stderr.write("form-decompile: conditionalAppearance item имеет scope — не воспроизводится в DSL (path: %s/%d/scope)\n" % (loc, i))
        sel_node = it.find('dcsset:selection', NS)
        if sel_node is not None and len(sel_node.findall('dcsset:item', NS)) > 0:
            entry['selection'] = build_selection(sel_node, '%s/%d/selection' % (loc, i))
        filter_node = it.find('dcsset:filter', NS)
        if filter_node is not None and len(filter_node.findall('dcsset:item', NS)) > 0:
            f = []
            for fc in filter_node.findall('dcsset:item', NS):
                bi = build_filter_item(fc, '%s/%d/filter' % (loc, i))
                if bi is not None:
                    f.append(bi)
            entry['filter'] = f
        app_node = it.find('dcsset:appearance', NS)
        ap = get_settings_appearance(app_node)
        if ap and len(ap) > 0:
            entry['appearance'] = ap
        pres_node = it.find('dcsset:presentation', NS)
        if pres_node is not None:
            pres = get_pres_by_type(pres_node)
            if pres is not None and pres != '':
                entry['presentation'] = pres
        vm_n = it.find('dcsset:viewMode', NS)
        if vm_n is not None:
            entry['viewMode'] = _text(vm_n)
        usid = get_text(it, 'dcsset:userSettingID')
        if usid:
            entry['userSettingID'] = 'auto'
        usp_n = it.find('dcsset:userSettingPresentation', NS)
        if usp_n is not None:
            usp = get_pres_text(usp_n)
            if usp:
                entry['userSettingPresentation'] = usp
        use_v = get_text(it, 'dcsset:use')
        if use_v == 'false':
            entry['use'] = False
        use_in_dont_use = []
        for ch in list(it):
            if not ch.tag.startswith('{%s}' % NS_DCSSET):
                continue
            ln = _local_name(ch.tag)
            mt = re.match(r'^useIn(.+)$', ln)
            if mt and _text(ch) == 'DontUse':
                short_name = mt.group(1)[0:1].lower() + mt.group(1)[1:]
                use_in_dont_use.append(short_name)
        if len(use_in_dont_use) > 0:
            entry['useInDontUse'] = use_in_dont_use
        out.append(entry)
        i += 1
    return out


# Общие layout-свойства → в obj (симметрично Emit-Layout компилятора).
def add_layout(obj, node):
    if get_child(node, 'DefaultItem') == 'true':
        obj['defaultItem'] = True
    soi = get_child(node, 'SkipOnInput')
    if soi is not None:
        obj['skipOnInput'] = (soi == 'true')
    esd = get_child(node, 'EnableStartDrag')
    if esd is not None:
        obj['enableStartDrag'] = (esd == 'true')
    edr = get_child(node, 'EnableDrag')
    if edr is not None:
        obj['enableDrag'] = (edr == 'true')
    fdm = get_child(node, 'FileDragMode')
    if fdm:
        obj['fileDragMode'] = fdm
    # AutoMaxWidth: компилятор додумывает false для multiLine-input → захват факт. значения.
    amw_node = get_child(node, 'AutoMaxWidth')
    if amw_node == 'false':
        obj['autoMaxWidth'] = False
    elif amw_node == 'true':
        obj['autoMaxWidth'] = True
    elif get_child(node, 'MultiLine') == 'true':
        obj['autoMaxWidth'] = True
    mw = get_child(node, 'MaxWidth')
    if mw:
        obj['maxWidth'] = int(mw)
    if get_child(node, 'AutoMaxHeight') == 'false':
        obj['autoMaxHeight'] = False
    mh = get_child(node, 'MaxHeight')
    if mh:
        obj['maxHeight'] = int(mh)
    w = get_child(node, 'Width')
    if w:
        obj['width'] = int(w)
    h = get_child(node, 'Height')
    if h:
        obj['height'] = int(h)
    hs = get_child(node, 'HorizontalStretch')
    if hs is not None:
        obj['horizontalStretch'] = (hs == 'true')
    vs = get_child(node, 'VerticalStretch')
    if vs is not None:
        obj['verticalStretch'] = (vs == 'true')
    gha = get_child(node, 'GroupHorizontalAlign')
    if gha:
        obj['groupHorizontalAlign'] = gha
    gva = get_child(node, 'GroupVerticalAlign')
    if gva:
        obj['groupVerticalAlign'] = gva
    ha = get_child(node, 'HorizontalAlign')
    if ha:
        obj['horizontalAlign'] = ha
    for p in ('ShowInHeader', 'ShowInFooter', 'AutoCellHeight'):
        v = get_child(node, p)
        if v is not None:
            obj[p[0:1].lower() + p[1:]] = (v == 'true')
    fha = get_child(node, 'FooterHorizontalAlign')
    if fha:
        obj['footerHorizontalAlign'] = fha
    hha = get_child(node, 'HeaderHorizontalAlign')
    if hha:
        obj['headerHorizontalAlign'] = hha
    hdp = get_child(node, 'HeaderDataPath')
    if hdp:
        obj['headerDataPath'] = hdp
    hf_node = node.find('lf:HeaderFormat', NS)
    if hf_node is not None:
        hf = get_lang_text(hf_node)
        if hf is not None:
            obj['headerFormat'] = hf


# TitleLocation у check/radio: тега нет → ""; значение = умный дефолт → опускаем; иначе пишем.
def add_title_location(obj, node, smart_default):
    tl = get_child(node, 'TitleLocation')
    if tl is None:
        obj['titleLocation'] = ''
    elif tl != smart_default:
        obj['titleLocation'] = tl.lower()


# Разобрать <Events> элемента → упорядоченная мапа { ИмяСобытия: ИмяОбработчика }.
def get_events(node, el_name):
    ev = node.find('lf:Events', NS)
    if ev is None:
        return None
    events = OrderedDict()
    for e in ev.findall('lf:Event', NS):
        events[_attr(e, 'name')] = _text(e)
    if len(events) == 0:
        return None
    return events


# Инверсия Emit-XrFlag: role-adjustable boolean (UserVisible/View/Edit/Use).
def decompile_xr_flag(node, tag):
    el = node.find('{*}%s' % tag)
    if el is None:
        return None
    common_node = el.find('{*}Common')
    common = (common_node is not None and _text(common_node) == 'true')
    val_nodes = el.findall('{*}Value')
    if len(val_nodes) == 0:
        return common
    roles = OrderedDict()
    for v in val_nodes:
        rn = _attr(v, 'name')
        if re.match(r'^Role\.', rn):
            rn = rn[5:]
        roles[rn] = (_text(v) == 'true')
    o = OrderedDict()
    o['common'] = common
    o['roles'] = roles
    return o


# Командный интерфейс формы (<CommandInterface>): панели CommandBar + NavigationPanel.
def decompile_command_interface():
    ci_node = ROOT.find('lf:CommandInterface', NS)
    if ci_node is None:
        return None
    ci = OrderedDict()
    for panel in (('CommandBar', 'commandBar'), ('NavigationPanel', 'navigationPanel')):
        pn = ci_node.find('lf:%s' % panel[0], NS)
        if pn is None:
            continue
        items = []
        for it in pn.findall('lf:Item', NS):
            o = OrderedDict()
            cmd = get_child(it, 'Command')
            o['command'] = _ps_str(cmd)
            ty = get_child(it, 'Type')
            if ty and ty != 'Auto':
                o['type'] = ty
            at = get_child(it, 'Attribute')
            if at:
                o['attribute'] = at
            cg = get_child(it, 'CommandGroup')
            if cg:
                o['group'] = cg
            idx = get_child(it, 'Index')
            if idx is not None:
                o['index'] = int(idx)
            dv = get_child(it, 'DefaultVisible')
            if dv is not None:
                o['defaultVisible'] = (dv == 'true')
            vis = decompile_xr_flag(it, 'Visible')
            if vis is not None:
                o['visible'] = vis
            # Голый элемент (только command) → строка-shorthand; иначе объект
            if len(o) == 1:
                items.append(_ps_str(cmd))
            else:
                items.append(o)
        if len(items) > 0:
            ci[panel[1]] = items
    if len(ci) > 0:
        return ci
    return None


# <FunctionalOptions><Item>FunctionalOption.X</Item>…> → массив строк (префикс снят; GUID — как есть).
def decompile_functional_options(node):
    fo_node = node.find('lf:FunctionalOptions', NS)
    if fo_node is None:
        return None
    opts = []
    for it in fo_node.findall('lf:Item', NS):
        t = re.sub(r'^FunctionalOption\.', '', (_text(it) or '').strip())
        opts.append(t)
    if len(opts) > 0:
        return opts
    return None


# Колонка реквизита (прямая или внутри AdditionalColumns): name/type/title/functionalOptions.
def decompile_attr_column(c):
    co = OrderedDict()
    co['name'] = _attr(c, 'name')
    cty = decompile_type(c.find('lf:Type', NS))
    if cty:
        co['type'] = cty
    ct_node = c.find('lf:Title', NS)
    if ct_node is not None:
        t = get_lang_text_ws(ct_node)
        if t is not None:
            co['title'] = t
    cfc = get_child(c, 'FillCheck')
    if cfc:
        co['fillCheck'] = cfc
    cfo = decompile_functional_options(c)
    if _ps_truthy(cfo):
        co['functionalOptions'] = cfo
    cv = decompile_xr_flag(c, 'View')
    if cv is not None:
        co['view'] = cv
    ce = decompile_xr_flag(c, 'Edit')
    if ce is not None:
        co['edit'] = ce
    return co


# Картинка-ссылка с прозрачностью (HeaderPicture/FooterPicture/…). Дефолт loadTransparent=false.
def get_picture_ref(node, pic_tag):
    ref = node.find('lf:%s/xr:Ref' % pic_tag, NS)
    abs_ = node.find('lf:%s/xr:Abs' % pic_tag, NS)
    if ref is None and abs_ is None:
        return None
    src = _text(ref) if ref is not None else 'abs:%s' % _text(abs_)
    lt = node.find('lf:%s/xr:LoadTransparent' % pic_tag, NS)
    lt_true = (lt is not None and _text(lt) == 'true')
    tpx = node.find('lf:%s/xr:TransparentPixel' % pic_tag, NS)
    if not lt_true and tpx is None:
        return src
    o = OrderedDict([('src', src)])
    if lt_true:
        o['loadTransparent'] = True
    if tpx is not None:
        o['transparentPixel'] = OrderedDict([('x', int(_attr(tpx, 'x'))), ('y', int(_attr(tpx, 'y')))])
    return o


# <Picture> кнопки/попапа/команды. Дефолт LoadTransparent=true (обратная конвенция).
def set_command_picture(obj, node):
    ref = node.find('lf:Picture/xr:Ref', NS)
    abs_ = node.find('lf:Picture/xr:Abs', NS)
    if ref is None and abs_ is None:
        return
    src = _text(ref) if ref is not None else 'abs:%s' % _text(abs_)
    lt = node.find('lf:Picture/xr:LoadTransparent', NS)
    lt_false = (lt is not None and _text(lt) == 'false')
    tpx = node.find('lf:Picture/xr:TransparentPixel', NS)
    if tpx is not None:
        o = OrderedDict([('src', src)])
        if lt_false:
            o['loadTransparent'] = False
        o['transparentPixel'] = OrderedDict([('x', int(_attr(tpx, 'x'))), ('y', int(_attr(tpx, 'y')))])
        obj['picture'] = o
    else:
        obj['picture'] = src
        if lt_false:
            obj['loadTransparent'] = False


# Шрифт <Font ...> → строка-ref (если только ref+kind=StyleItem) или объект-атрибуты.
def build_font_value(f):
    present = []
    for a in ('ref', 'faceName', 'height', 'bold', 'italic', 'underline', 'strikeout', 'kind', 'scale'):
        if a in f.attrib:
            present.append(a)
    if len(present) == 2 and ('ref' in present) and _attr(f, 'kind') == 'StyleItem':
        return _attr(f, 'ref')
    o = OrderedDict()
    for k in present:
        v = _attr(f, k)
        if k in ('height', 'scale') and re.match(r'^-?\d+$', v):
            o[k] = int(v)
        elif k in ('bold', 'italic', 'underline', 'strikeout'):
            o[k] = (v == 'true')
        else:
            o[k] = v
    return o


# Граница <Border> → строка-ref (из стиля) или объект {width, style}.
def build_border_value(b):
    if 'ref' in b.attrib:
        return _attr(b, 'ref')
    o = OrderedDict()
    if 'width' in b.attrib:
        w = _attr(b, 'width')
        o['width'] = int(w) if re.match(r'^-?\d+$', w) else w
    st = b.find('v8ui:style', NS)
    if st is not None:
        o['style'] = _text(st)
    return o


# Порядок ключей цвета = .NET Hashtable enumeration (захвачено из PS 5.1), НЕ порядок литерала.
COLOR_MAP = [
    ('BackColor', 'backColor'),
    ('TitleBackColor', 'titleBackColor'),
    ('TitleTextColor', 'titleTextColor'),
    ('TextColor', 'textColor'),
    ('FooterTextColor', 'footerTextColor'),
    ('FooterBackColor', 'footerBackColor'),
    ('BorderColor', 'borderColor'),
]


# Оформление элемента (цвета/шрифты/граница) → canonical DSL-ключи. Цвет — verbatim-строка.
def add_appearance(obj, node):
    for tag, key in COLOR_MAP:
        c = node.find('lf:%s' % tag, NS)
        if c is not None:
            obj[key] = _text(c)
    for pair in (('Font', 'font'), ('TitleFont', 'titleFont'), ('FooterFont', 'footerFont')):
        f = node.find('lf:%s' % pair[0], NS)
        if f is not None:
            obj[pair[1]] = build_font_value(f)
    b = node.find('lf:Border', NS)
    if b is not None:
        obj['border'] = build_border_value(b)


def add_common_props(obj, node, el_name):
    add_appearance(obj, node)
    if get_child(node, 'Visible') == 'false':
        obj['hidden'] = True
    if get_child(node, 'Enabled') == 'false':
        obj['disabled'] = True
    if get_child(node, 'ReadOnly') == 'true':
        obj['readOnly'] = True
    uv = decompile_xr_flag(node, 'UserVisible')
    if uv is not None:
        obj['userVisible'] = uv
    title_node = node.find('lf:Title', NS)
    if title_node is not None:
        t = get_lang_text_ws(title_node)
        if t is not None:
            obj['title'] = t
    tt_node = node.find('lf:ToolTip', NS)
    if tt_node is not None:
        tt = get_lang_text_ws(tt_node)
        if tt is not None:
            obj['tooltip'] = tt
    ttr = get_child(node, 'ToolTipRepresentation')
    if ttr:
        obj['tooltipRepresentation'] = ttr
    hp = get_picture_ref(node, 'HeaderPicture')
    if hp is not None:
        obj['headerPicture'] = hp
    fp = get_picture_ref(node, 'FooterPicture')
    if fp is not None:
        obj['footerPicture'] = fp
    ev = get_events(node, el_name)
    if ev:
        obj['events'] = ev
    # CommandSet — список отключённых команд редактора (только <ExcludedCommand>).
    cs_node = node.find('lf:CommandSet', NS)
    if cs_node is not None:
        exc = []
        for ec in cs_node.findall('lf:ExcludedCommand', NS):
            exc.append(_text(ec))
        if len(exc) > 0:
            obj['excludedCommands'] = exc


# --- 3. Type decompile (inverse of Emit-Type) ---
def decompile_type(type_node):
    if type_node is None:
        return None
    parts = []
    for vt in type_node.findall('v8:Type', NS):
        raw = (_text(vt) or '').strip()
        short = raw
        # break-эквивалент: ветви взаимоисключающи (общий v8|v8ui не перетирает специфичные).
        if re.match(r'^xs:string$', raw):
            ln = type_node.find('v8:StringQualifiers/v8:Length', NS)
            al = type_node.find('v8:StringQualifiers/v8:AllowedLength', NS)
            fixed = (al is not None and _text(al) == 'Fixed')   # Variable = дефолт; Fixed — явно
            if ln is not None and int(_text(ln)) > 0:
                short = ('string(%s,fixed)' % _text(ln)) if fixed else ('string(%s)' % _text(ln))
            else:
                short = 'string'   # Length=0 → всегда Variable (корпус)
        elif re.match(r'^xs:decimal$', raw):
            d = type_node.find('v8:NumberQualifiers/v8:Digits', NS)
            f = type_node.find('v8:NumberQualifiers/v8:FractionDigits', NS)
            sgn = type_node.find('v8:NumberQualifiers/v8:AllowedSign', NS)
            dd = _text(d) if d is not None else '0'
            ff = _text(f) if f is not None else '0'
            if sgn is not None and _text(sgn) == 'Nonnegative':
                short = 'decimal(%s,%s,nonneg)' % (dd, ff)
            else:
                short = 'decimal(%s,%s)' % (dd, ff)
        elif re.match(r'^xs:boolean$', raw):
            short = 'boolean'
        elif re.match(r'^xs:dateTime$', raw):
            df = type_node.find('v8:DateQualifiers/v8:DateFractions', NS)
            dfv = _text(df) if df is not None else 'DateTime'
            if dfv == 'Date':
                short = 'date'
            elif dfv == 'Time':
                short = 'time'
            else:
                short = 'dateTime'
        else:
            m_cfg = re.match(r'^cfg:(.+)$', raw)
            if m_cfg:
                short = m_cfg.group(1)
            elif re.match(r'^(v8|v8ui):', raw):
                # Платформенный тип: friendly-шорткат если есть, иначе verbatim (не теряем v8:UUID и т.п.).
                rev = {
                    'v8:ValueTable': 'ValueTable', 'v8:ValueTree': 'ValueTree', 'v8:ValueListType': 'ValueList',
                    'v8:TypeDescription': 'TypeDescription', 'v8:Universal': 'Universal',
                    'v8:FixedArray': 'FixedArray', 'v8:FixedStructure': 'FixedStructure',
                    'v8ui:FormattedString': 'FormattedString', 'v8ui:Picture': 'Picture', 'v8ui:Color': 'Color', 'v8ui:Font': 'Font',
                }
                short = rev.get(raw, raw)
            else:
                short = raw
        parts.append(short)
    # TypeSet (набор типов): префикс cfg:/v8: снимаем — обратный роутинг в компиляторе по форме токена.
    for ts in type_node.findall('v8:TypeSet', NS):
        raw = (_text(ts) or '').strip()
        short = re.sub(r'^(v8ui|v8|cfg):', '', raw)
        parts.append(short)
    # TypeId — тип по глобальному стабильному GUID → маркер 'typeid:GUID' (компилятор разворачивает).
    for ti in type_node.findall('v8:TypeId', NS):
        parts.append('typeid:' + (_text(ti) or '').strip())
    if len(parts) == 0:
        return None
    if len(parts) == 1:
        return parts[0]
    return ' | '.join(parts)


# Ограничения использования (useRestriction/attributeUseRestriction) → объект {field?,condition?,group?,order?}.
def build_restrict_obj(node):
    r = OrderedDict()
    for k in ('field', 'condition', 'group', 'order'):
        if get_child(node, k) == 'true':
            r[k] = True
    return r


# Вычисляемое поле DataSet динамического списка (<CalculatedField>) → объектная модель.
def build_calc_field(cf_node):
    o = OrderedDict()
    o['dataPath'] = get_child(cf_node, 'dataPath')
    o['expression'] = get_child(cf_node, 'expression')
    tn = cf_node.find('dcssch:title', NS)
    if tn is not None:
        t = get_lang_text(tn)
        if t is not None:
            o['title'] = t
    vt = cf_node.find('dcssch:valueType', NS)
    if vt is not None:
        v = decompile_type(vt)
        if v:
            o['valueType'] = v
    ur = cf_node.find('dcssch:useRestriction', NS)
    if ur is not None:
        r = OrderedDict()
        for k in ('field', 'condition', 'group', 'order'):
            if get_child(ur, k) == 'true':
                r[k] = True
        if len(r) > 0:
            o['useRestriction'] = r
    pe = get_child(cf_node, 'presentationExpression')
    if pe is not None and pe != '':
        o['presentationExpression'] = pe
    oe_nodes = cf_node.findall('dcssch:orderExpression', NS)
    if len(oe_nodes) > 0:
        oes = []
        for oen in oe_nodes:
            eo = OrderedDict()
            expr_n = oen.find('{*}expression')
            ot_n = oen.find('{*}orderType')
            ao_n = oen.find('{*}autoOrder')
            eo['expression'] = _text(expr_n) if expr_n is not None else ''
            if ot_n is not None and _text(ot_n) != 'Asc':
                eo['orderType'] = _text(ot_n)
            if ao_n is not None and _text(ao_n) == 'true':
                eo['autoOrder'] = True
            oes.append(eo)
        o['orderExpression'] = oes
    return o


# Параметры выбора входа дин-списка (<inputParameters>) → массив. Зеркало Emit-DLInputParameters.
def build_dl_input_parameters(ip_node):
    items = []
    for it in ip_node.findall('dcscor:item', NS):
        io = OrderedDict()
        io['parameter'] = get_child(it, 'parameter')
        use_n = it.find('dcscor:use', NS)
        if use_n is not None and _text(use_n) == 'false':
            io['use'] = False
        val_n = it.find('dcscor:value', NS)
        if val_n is not None:
            vt = _attr(val_n, 'type', NS_XSI)
            if re.search(r'ChoiceParameters$', vt):
                cps = []
                for cpi in val_n.findall('dcscor:item', NS):
                    cpo = OrderedDict()
                    cpo['name'] = get_child(cpi, 'choiceParameter')
                    vals = []
                    for cv in cpi.findall('dcscor:value', NS):
                        vals.append(convert_typed_value(_text(cv), _attr(cv, 'type', NS_XSI)))
                    cpo['values'] = vals
                    cps.append(cpo)
                io['choiceParameters'] = cps
            elif re.search(r'ChoiceParameterLinks$', vt):
                cpls = []
                for cpi in val_n.findall('dcscor:item', NS):
                    cpo = OrderedDict()
                    cpo['name'] = get_child(cpi, 'choiceParameter')
                    cpo['value'] = get_child(cpi, 'value')
                    md = get_child(cpi, 'mode')
                    if md and md != 'Auto':
                        cpo['mode'] = md
                    cpls.append(cpo)
                io['choiceParameterLinks'] = cpls
            elif re.search(r'TypeLink$', vt):
                # Связь по типу: field + linkItem — структурное значение, НЕ склеивать InnerText в строку.
                tlo = OrderedDict()
                tlf = get_child(val_n, 'field')
                if tlf is not None:
                    tlo['field'] = tlf
                tli = get_child(val_n, 'linkItem')
                if tli is not None:
                    tlo['linkItem'] = int(tli) if re.match(r'^-?\d+$', tli) else tli
                io['typeLink'] = tlo
            else:
                if _attr(val_n, 'nil', NS_XSI) != 'true':
                    io['value'] = convert_typed_value(_text(val_n), vt)
        items.append(io)
    return items


# dcsset:dataParameters → массив (shorthand "Имя @off" / объект для типизированного значения).
def build_form_data_parameters(dp_node):
    entries = []
    for it in dp_node.findall('dcscor:item', NS):
        pn = get_text(it, 'dcscor:parameter')
        use = get_text(it, 'dcscor:use')
        val_nodes = it.findall('dcscor:value', NS)
        val_node = val_nodes[0] if len(val_nodes) >= 1 else None
        usid_n = it.find('dcsset:userSettingID', NS)
        vm_n = it.find('dcsset:viewMode', NS)
        usp_n = it.find('dcsset:userSettingPresentation', NS)
        if val_node is not None or usid_n is not None or vm_n is not None or usp_n is not None:
            obj = OrderedDict([('parameter', pn)])
            if len(val_nodes) > 1:
                # Список значений параметра (valueListAllowed) — все <dcscor:value> массивом
                obj['value'] = [_text(v) for v in val_nodes]
                vt0 = _attr(val_nodes[0], 'type', NS_XSI)
                if vt0:
                    obj['valueType'] = vt0
            elif val_node is not None:
                if _attr(val_node, 'nil', NS_XSI) == 'true':
                    obj['nilValue'] = True
                else:
                    v_type = _attr(val_node, 'type', NS_XSI)
                    v_val = _text(val_node)
                    if re.search(r'decimal$', v_type) and re.match(r'^-?\d+$', v_val):
                        obj['value'] = int(v_val)
                    elif re.search(r'boolean$', v_type):
                        obj['value'] = (v_val == 'true')
                    else:
                        obj['value'] = v_val
                    if v_type:
                        obj['valueType'] = v_type
            if use == 'false':
                obj['use'] = False
            if usid_n is not None:
                obj['userSettingID'] = 'auto'
            if vm_n is not None:
                obj['viewMode'] = _text(vm_n)
            if usp_n is not None:
                usp = get_pres_text(usp_n)
                if usp is not None:
                    obj['userSettingPresentation'] = usp
            entries.append(obj)
        else:
            s = pn
            if use == 'false':
                s += ' @off'
            entries.append(s)
    return entries


def build_dl_parameter(p_node):
    name = get_child(p_node, 'name')
    o = OrderedDict()
    o['name'] = name
    # title — опускаем, если совпадает с авто-выводом из имени (ru-only)
    title_node = p_node.find('dcssch:title', NS)
    if title_node is not None:
        t = get_lang_text(title_node)
        if t is not None:
            auto = title_from_name(name)
            if not (isinstance(t, str) and _ps_ieq(t, auto)):
                o['title'] = t
    vt_node = p_node.find('dcssch:valueType', NS)
    type_val = None
    if vt_node is not None:
        type_val = decompile_type(vt_node)
        if type_val:
            o['type'] = type_val
    # value — опускаем nil (дефолт), КРОМЕ valueListAllowed+nil (явный маркер value:null).
    v_nodes = p_node.findall('dcssch:value', NS)
    if len(v_nodes) > 1:
        o['value'] = [convert_typed_value(_text(v), _attr(v, 'type', NS_XSI)) for v in v_nodes]
    elif len(v_nodes) == 1:
        v_node = v_nodes[0]
        if _attr(v_node, 'nil', NS_XSI) != 'true':
            o['value'] = convert_typed_value(_text(v_node), _attr(v_node, 'type', NS_XSI))
        elif get_child(p_node, 'valueListAllowed') == 'true':
            o['value'] = None
    if get_child(p_node, 'useRestriction') == 'false':
        o['useRestriction'] = False
    expr = get_child(p_node, 'expression')
    if expr is not None and expr != '':
        o['expression'] = expr
    av_nodes = p_node.findall('dcssch:availableValue', NS)
    if len(av_nodes) > 0:
        avs = []
        for avn in av_nodes:
            avo = OrderedDict()
            avv = avn.find('dcssch:value', NS)
            if avv is not None and _attr(avv, 'nil', NS_XSI) != 'true':
                avo['value'] = convert_typed_value(_text(avv), _attr(avv, 'type', NS_XSI))
            else:
                avo['value'] = None
            avp = avn.find('dcssch:presentation', NS)
            if avp is not None:
                pres = get_lang_text(avp)
                if pres is not None:
                    avo['presentation'] = pres
            avs.append(avo)
        o['availableValues'] = avs
    if get_child(p_node, 'valueListAllowed') == 'true':
        o['valueListAllowed'] = True
    if get_child(p_node, 'availableAsField') == 'false':
        o['availableAsField'] = False
    ip_node = p_node.find('dcssch:inputParameters', NS)
    if ip_node is not None:
        ip = build_dl_input_parameters(ip_node)
        if len(ip) > 0:
            o['inputParameters'] = ip[0] if len(ip) == 1 else ip   # PS unwrap @() одноэлементного → объект
    if get_child(p_node, 'denyIncompleteValues') == 'true':
        o['denyIncompleteValues'] = True
    use = get_child(p_node, 'use')
    if use is not None and use != '':
        o['use'] = use

    # Компактизация: {name} → "name"; {name, type} → "name: type"; иначе объект.
    keys = list(o.keys())
    if len(keys) == 1:
        return name
    if len(keys) == 2 and 'type' in o and isinstance(type_val, str):
        return '%s: %s' % (name, type_val)
    return o


# --- 4. Element dispatch ---
# Lookup-карта (диспетчер по тегу → DSL-ключ); порядок не влияет на вывод.
ELEMENT_KEY = {
    'UsualGroup': 'group', 'ColumnGroup': 'columnGroup', 'ButtonGroup': 'buttonGroup', 'InputField': 'input', 'CheckBoxField': 'check',
    'RadioButtonField': 'radio', 'LabelDecoration': 'label', 'LabelField': 'labelField',
    'PictureDecoration': 'picture', 'PictureField': 'picField', 'CalendarField': 'calendar',
    'Table': 'table', 'Pages': 'pages', 'Page': 'page', 'Button': 'button', 'CommandBar': 'cmdBar', 'Popup': 'popup',
    'SearchStringAddition': 'searchString', 'ViewStatusAddition': 'viewStatus', 'SearchControlAddition': 'searchControl',
    'SpreadSheetDocumentField': 'spreadsheet', 'HTMLDocumentField': 'html', 'TextDocumentField': 'textDoc',
    'FormattedDocumentField': 'formattedDoc', 'ProgressBarField': 'progressBar', 'TrackBarField': 'trackBar',
    'ChartField': 'chart', 'GraphicalSchemaField': 'graphicalSchema', 'PlannerField': 'planner',
    'PeriodField': 'periodField', 'DendrogramField': 'dendrogram', 'GanttChartField': 'ganttChart',
}

# Простые скаляры элемента (pass-through, зеркало $script:genericScalars). ПОРЯДОК значим (ordered).
GENERIC_SCALARS = [
    ('VerticalAlign', 'verticalAlign', 'value'),
    ('ThroughAlign', 'throughAlign', 'value'),
    ('EnableContentChange', 'enableContentChange', 'bool'),
    ('PictureSize', 'pictureSize', 'value'),
    ('TitleHeight', 'titleHeight', 'value'),
    ('ChildItemsWidth', 'childItemsWidth', 'value'),
    ('ShowLeftMargin', 'showLeftMargin', 'bool'),
    ('CellHyperlink', 'cellHyperlink', 'bool'),
    ('ViewMode', 'viewMode', 'value'),
    ('VerticalScrollBar', 'verticalScrollBar', 'value'),
    ('RowInputMode', 'rowInputMode', 'value'),
    ('Mask', 'mask', 'value'),
    ('CreateButton', 'createButton', 'bool'),
    ('FixingInTable', 'fixingInTable', 'value'),
    ('VerticalSpacing', 'verticalSpacing', 'value'),
    ('HorizontalScrollBar', 'horizontalScrollBar', 'value'),
    ('ViewScalingMode', 'viewScalingMode', 'value'),
    ('Output', 'output', 'value'),
    ('SelectionShowMode', 'selectionShowMode', 'value'),
    ('PointerType', 'pointerType', 'value'),
    ('DrawingSelectionShowMode', 'drawingSelectionShowMode', 'value'),
    ('WarningOnEditRepresentation', 'warningOnEditRepresentation', 'value'),
    ('MarkingAppearance', 'markingAppearance', 'value'),
    ('Protection', 'protection', 'bool'),
    ('Edit', 'edit', 'bool'),
    ('ShowGrid', 'showGrid', 'bool'),
    ('ShowGroups', 'showGroups', 'bool'),
    ('ShowHeaders', 'showHeaders', 'bool'),
    ('ShowRowAndColumnNames', 'showRowAndColumnNames', 'bool'),
    ('ShowCellNames', 'showCellNames', 'bool'),
    ('ShowPercent', 'showPercent', 'bool'),
    ('HorizontalSpacing', 'horizontalSpacing', 'value'),
    ('RepresentationInContextMenu', 'representationInContextMenu', 'value'),
    ('SettingsNamedItemDetailedRepresentation', 'settingsNamedItemDetailedRepresentation', 'bool'),
    ('ItemHeight', 'itemHeight', 'value'),
    ('DropListWidth', 'dropListWidth', 'value'),
    ('TitleDataPath', 'titleDataPath', 'value'),
    ('ExtendedEdit', 'extendedEdit', 'bool'),
    ('MaxRowsCount', 'maxRowsCount', 'value'),
    ('AutoMaxRowsCount', 'autoMaxRowsCount', 'bool'),
    ('HeightControlVariant', 'heightControlVariant', 'value'),
    ('EditTextUpdate', 'editTextUpdate', 'value'),
    ('ControlRepresentation', 'controlRepresentation', 'value'),
    ('ShapeRepresentation', 'shapeRepresentation', 'value'),
    ('AutoAddIncomplete', 'autoAddIncomplete', 'bool'),
    ('MarkNegatives', 'markNegatives', 'bool'),
    ('InitialListView', 'initialListView', 'value'),
    ('ChoiceListHeight', 'choiceListHeight', 'value'),
    ('ThreeState', 'threeState', 'bool'),
    ('ScrollOnCompress', 'scrollOnCompress', 'bool'),
    ('Shortcut', 'shortcut', 'value'),
    ('IncompleteChoiceMode', 'incompleteChoiceMode', 'value'),
    ('EqualColumnsWidth', 'equalColumnsWidth', 'bool'),
    ('ChildrenAlign', 'childrenAlign', 'value'),
    ('ImageScale', 'imageScale', 'value'),
    ('Zoomable', 'zoomable', 'bool'),
    ('Shape', 'shape', 'value'),
    ('PictureLocation', 'pictureLocation', 'value'),
    ('EqualItemsWidth', 'equalItemsWidth', 'bool'),
    ('ItemTitleHeight', 'itemTitleHeight', 'value'),
    ('SpecialTextInputMode', 'specialTextInputMode', 'value'),
    ('ItemWidth', 'itemWidth', 'value'),
    ('ShowCheckBoxesInDropList', 'showCheckBoxesInDropList', 'bool'),
    ('MultipleValueDataPath', 'multipleValueDataPath', 'value'),
    ('MultipleValuePresentDataPath', 'multipleValuePresentDataPath', 'value'),
    ('AutoShowOpenButtonMode', 'autoShowOpenButtonMode', 'value'),
    ('AutoShowClearButtonMode', 'autoShowClearButtonMode', 'value'),
    ('MultipleValuesTextColor', 'multipleValuesTextColor', 'value'),
    ('MultipleValuesBackColor', 'multipleValuesBackColor', 'value'),
    ('MultipleValuePictureShape', 'multipleValuePictureShape', 'value'),
    ('MultipleValuePictureDataPath', 'multipleValuePictureDataPath', 'value'),
    ('AutoCorrectionOnTextInput', 'autoCorrectionOnTextInput', 'value'),
    ('SpellCheckingOnTextInput', 'spellCheckingOnTextInput', 'value'),
    ('CommandUniqueness', 'commandUniqueness', 'bool'),
    ('AllowInputEmptyMultipleValues', 'allowInputEmptyMultipleValues', 'bool'),
    ('BehaviorOnHorizontalCompression', 'behaviorOnHorizontalCompression', 'value'),
]


# Захват generic-скаляров. Специфичная обработка (если ключ уже задан) — побеждает.
def add_generic_scalars(obj, node):
    for tag, key, kind in GENERIC_SCALARS:
        if key in obj:
            continue
        v = get_child(node, tag)
        if v is None:
            continue
        if kind == 'bool':
            obj[key] = (v == 'true')
        else:
            obj[key] = v


def decompile_children(parent_node, child_container='ChildItems'):
    container = parent_node.find('lf:%s' % child_container, NS)
    if container is None:
        return None
    lst = []
    for child in list(container):
        if _local_name(child.tag) in COMPANION_TAGS:
            continue
        el = decompile_element(child)
        if el is not None:
            lst.append(el)
    if len(lst) == 0:
        return None
    return lst


# Инверсия Emit-CompanionPanel: companion-панель (ContextMenu/AutoCommandBar) с контентом → объект либо None.
def decompile_companion_panel(node, tag, is_dyn_list_table=False):
    p = node.find('lf:%s' % tag, NS)
    if p is None:
        return None
    autofill_raw = get_child(p, 'Autofill')
    halign = get_child(p, 'HorizontalAlign')
    kids = decompile_children(p)
    has_kids = kids is not None and len(kids) > 0
    if is_dyn_list_table and tag == 'AutoCommandBar' and not has_kids and not halign:
        if autofill_raw == 'false':
            return None                                  # = дефолт эвристики → молчим
        return OrderedDict([('autofill', True)])         # голая панель → отклонение
    if not has_kids and autofill_raw is None and not halign:
        return None
    o = OrderedDict()
    if halign:
        o['horizontalAlign'] = halign
    if autofill_raw == 'false':
        o['autofill'] = False
    elif autofill_raw == 'true':
        o['autofill'] = True
    if has_kids:
        o['children'] = kids
    return o


# Инверсия Emit-ChoiceList: <ChoiceList><xr:Item>… → [ { value, presentation? } ] либо None.
def decompile_choice_list(node):
    cl = node.find('lf:ChoiceList', NS)
    if cl is None:
        return None
    items = []
    for it in cl.findall('xr:Item', NS):
        val_node = it.find('xr:Value/lf:Value', NS)
        pres_node = it.find('xr:Value/lf:Presentation', NS)
        ci = OrderedDict()
        if val_node is not None:
            if _attr(val_node, 'nil', NS_XSI) == 'true':
                # nil-значение — компилятор эмитит <Value xsi:nil="true"/>.
                ci['valueType'] = 'nil'
            else:
                xsi_type = _attr(val_node, 'type', NS_XSI)
                ci['value'] = convert_typed_value(_text(val_node), xsi_type)
                # Не-примитивный тип / raw-ссылка по GUID → сохраняем valueType.
                if xsi_type and not re.match(r'^xs:(string|decimal|boolean|dateTime)$', xsi_type) and \
                        (xsi_type != 'xr:DesignTimeRef' or re.match(r'^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-', _text(val_node) or '')):
                    ci['valueType'] = xsi_type
        # Presentation: непустой → текст; пустой <Presentation/> → "" суппресс-маркер.
        if pres_node is not None:
            p = get_lang_text_ws(pres_node)
            if p is not None and p != '':
                ci['presentation'] = p
            else:
                ci['presentation'] = ''
        items.append(ci)
    if len(items) > 0:
        return items
    return None


# Значение Параметра выбора (<lf:Value>): скаляр или v8:FixedArray → массив скаляров.
def convert_choice_param_value(val_node):
    vt = _attr(val_node, 'type', NS_XSI)
    if re.search(r'FixedArray$', vt):
        arr = []
        for it in val_node.findall('v8:Value', NS):
            inner = it.find('lf:Value', NS)
            if inner is not None:
                arr.append(convert_typed_value(_text(inner), _attr(inner, 'type', NS_XSI)))
        return arr
    return convert_typed_value(_text(val_node), vt)


# Инверсия Emit-ChoiceParameters: <ChoiceParameters><app:item name="X"><app:value><Value…> → [{name, value}].
def decompile_choice_parameters(node):
    cpn = node.find('lf:ChoiceParameters', NS)
    if cpn is None:
        return None
    items = []
    for it in cpn.findall('app:item', NS):
        o = OrderedDict()
        o['name'] = _attr(it, 'name')
        val_node = it.find('app:value/lf:Value', NS)
        if val_node is not None:
            o['value'] = convert_choice_param_value(val_node)
        items.append(o)
    if len(items) > 0:
        return items
    return None


# Инверсия Emit-ChoiceParameterLinks → [{name, dataPath, valueChange?}].
def decompile_choice_parameter_links(node):
    cln = node.find('lf:ChoiceParameterLinks', NS)
    if cln is None:
        return None
    items = []
    for lk in cln.findall('xr:Link', NS):
        o = OrderedDict()
        o['name'] = get_text(lk, 'xr:Name')
        o['dataPath'] = get_text(lk, 'xr:DataPath')
        vc = get_text(lk, 'xr:ValueChange')
        if vc and vc != 'Clear':
            o['valueChange'] = vc
        items.append(o)
    if len(items) > 0:
        return items
    return None


# Инверсия Emit-TypeLink: <TypeLink><xr:DataPath><xr:LinkItem> → {dataPath, linkItem}.
def decompile_type_link(node):
    tn = node.find('lf:TypeLink', NS)
    if tn is None:
        return None
    o = OrderedDict()
    o['dataPath'] = get_text(tn, 'xr:DataPath')
    li = get_text(tn, 'xr:LinkItem')
    if li is not None and li != '':
        o['linkItem'] = int(li)
    return o


# Захват <Format>/<EditFormat> (LocalStringType) → format/editFormat.
def add_format_props(obj, node):
    fmt = node.find('lf:Format', NS)
    if fmt is not None:
        t = get_lang_text(fmt)
        if t is not None and t != '':
            obj['format'] = t
    efmt = node.find('lf:EditFormat', NS)
    if efmt is not None:
        t = get_lang_text(efmt)
        if t is not None and t != '':
            obj['editFormat'] = t


# Ядро дополнения: source + Add-CommonProps + horizontalLocation. Layout добавляется отдельно.
def add_addition_core(obj, node, el_name):
    src = node.find('lf:AdditionSource/lf:Item', NS)
    if src is not None:
        obj['source'] = _text(src)
    add_common_props(obj, node, el_name)
    hl = get_child(node, 'HorizontalLocation')
    if hl:
        obj['horizontalLocation'] = hl.lower()


# Стандартные дополнения уровня таблицы → карта { тип: {отклонения} }.
def decompile_table_additions(table_node, table_name):
    tag_to_key = {'SearchStringAddition': 'searchString', 'ViewStatusAddition': 'viewStatus', 'SearchControlAddition': 'searchControl'}
    m = OrderedDict()
    for child in list(table_node):
        ln = _local_name(child.tag)
        if ln not in tag_to_key:
            continue
        key = tag_to_key[ln]
        nm = _attr(child, 'name')
        o = OrderedDict()
        o[key] = nm
        add_addition_core(o, child, nm)
        add_layout(o, child)
        del o[key]                                                          # имя авто
        if 'source' in o and o['source'] == table_name:
            del o['source']                                                 # source=таблица дефолт
        if len(o) > 0:
            m[key] = o
    if len(m) > 0:
        return m
    return None


# Спец-поля «документ/датчик» — общий скелет поля.
def decompile_simple_field(obj, node, name, key):
    obj[key] = name
    dp = get_child(node, 'DataPath')
    if dp:
        obj['path'] = dp
    add_common_props(obj, node, name)
    tl = get_child(node, 'TitleLocation')
    if tl:
        obj['titleLocation'] = tl.lower()
    em = get_child(node, 'EditMode')
    if em:
        obj['editMode'] = em


# Числовые скаляры датчиков (ProgressBar/TrackBar) — без xsi:type.
def add_gauge_scalars(obj, node, tags):
    for p in tags:
        v = get_child(node, p)
        if v is None:
            continue
        key = p[0:1].lower() + p[1:]
        if re.match(r'^-?\d+$', v):
            obj[key] = int(v)
        else:
            obj[key] = v


def decompile_element(node):
    tag = _local_name(node.tag)
    if tag not in ELEMENT_KEY:
        fail_ring3("элемент <%s>" % tag, "ChildItems/%s" % tag)
    key = ELEMENT_KEY[tag]
    name = _attr(node, 'name')
    obj = OrderedDict()

    if tag == 'UsualGroup':
        g = get_child(node, 'Group')
        gmap = {'Horizontal': 'horizontal', 'Vertical': 'vertical', 'AlwaysHorizontal': 'alwaysHorizontal', 'AlwaysVertical': 'alwaysVertical', 'HorizontalIfPossible': 'horizontalIfPossible'}
        if g and g in gmap:
            obj[key] = gmap[g]
        else:
            obj[key] = ''
        behavior = get_child(node, 'Behavior')
        if behavior:
            bmap = {'Usual': 'usual', 'Collapsible': 'collapsible', 'PopUp': 'popup'}
            obj['behavior'] = bmap[behavior] if behavior in bmap else behavior
        obj['name'] = name
        add_common_props(obj, node, name)
        rep = get_child(node, 'Representation')
        if rep:
            repmap = {'None': 'none', 'NormalSeparation': 'normal', 'WeakSeparation': 'weak', 'StrongSeparation': 'strong'}
            obj['representation'] = repmap[rep] if rep in repmap else rep
        st = get_child(node, 'ShowTitle')
        if st is not None:
            obj['showTitle'] = (st == 'true')
        cru = get_child(node, 'CurrentRowUse')
        if cru:
            obj['currentRowUse'] = cru
        crt = node.find('lf:CollapsedRepresentationTitle', NS)
        if crt is not None:
            ct = get_lang_text(crt)
            if ct is not None and ct != '':
                obj['collapsedTitle'] = ct
        if get_child(node, 'United') == 'false':
            obj['united'] = False
        if get_child(node, 'Collapsed') == 'true':
            obj['collapsed'] = True
        add_format_props(obj, node)
        kids = decompile_children(node)
        if kids:
            obj['children'] = kids
    elif tag == 'ColumnGroup':
        g = get_child(node, 'Group')
        gmap = {'Horizontal': 'horizontal', 'Vertical': 'vertical', 'InCell': 'inCell'}
        if g and g in gmap:
            obj[key] = gmap[g]
        else:
            obj[key] = ''
        obj['name'] = name
        add_common_props(obj, node, name)
        st = get_child(node, 'ShowTitle')
        if st is not None:
            obj['showTitle'] = (st == 'true')
        sih = get_child(node, 'ShowInHeader')
        if sih is not None:
            obj['showInHeader'] = to_bool(sih)
        kids = decompile_children(node)
        if kids:
            obj['children'] = kids
    elif tag == 'InputField':
        obj[key] = name
        dp = get_child(node, 'DataPath')
        if dp:
            obj['path'] = dp
        add_common_props(obj, node, name)
        ml_in = get_child(node, 'MultiLine')
        if ml_in is not None:
            obj['multiLine'] = (ml_in == 'true')
        pm_in = get_child(node, 'PasswordMode')
        if pm_in is not None:
            obj['passwordMode'] = (pm_in == 'true')
        mi = get_child(node, 'AutoMarkIncomplete')
        if mi is not None:
            obj['markIncomplete'] = (mi == 'true')
        em = get_child(node, 'EditMode')
        if em:
            obj['editMode'] = em
        tl = get_child(node, 'TitleLocation')
        if tl:
            obj['titleLocation'] = tl.lower()
        ih = node.find('lf:InputHint', NS)
        if ih is not None:
            t = get_lang_text_ws(ih)
            if t:
                obj['inputHint'] = t
        woe = node.find('lf:WarningOnEdit', NS)
        if woe is not None:
            t = get_lang_text_ws(woe)
            if t is not None:
                obj['warningOnEdit'] = t
        ftxt = node.find('lf:FooterText', NS)
        if ftxt is not None:
            t = get_lang_text_ws(ftxt)
            if t is not None:
                obj['footerText'] = t
        for p in ('ChoiceButton', 'ClearButton', 'SpinButton', 'DropListButton', 'ChoiceListButton'):
            v = get_child(node, p)
            if v is not None:
                obj[p[0:1].lower() + p[1:]] = to_bool(v)
        for p in ('Wrap', 'OpenButton', 'ListChoiceMode', 'ExtendedEditMultipleValues', 'ChooseType', 'QuickChoice', 'AutoChoiceIncomplete'):
            v = get_child(node, p)
            if v is not None:
                obj[p[0:1].lower() + p[1:]] = to_bool(v)
        for p in ('ChoiceForm', 'ChoiceHistoryOnInput', 'ChoiceFoldersAndItems', 'FooterDataPath'):
            v = get_child(node, p)
            if v is not None:
                obj[p[0:1].lower() + p[1:]] = v
        for p in ('MinValue', 'MaxValue'):
            mn = node.find('lf:%s' % p, NS)
            if mn is not None:
                xt = _attr(mn, 'type', NS_XSI)
                txt = _text(mn)
                k = p[0:1].lower() + p[1:]
                if re.search(r'decimal|int', xt):
                    if re.match(r'^-?\d+$', txt):
                        obj[k] = int(txt)
                    elif re.match(r'^-?\d+\.\d+$', txt):
                        obj[k] = Decimal(txt)
                    else:
                        obj[k] = txt
                else:
                    obj[k] = txt
        tde = get_child(node, 'TypeDomainEnabled')
        if tde is not None:
            obj['typeDomainEnabled'] = to_bool(tde)
        at_node = node.find('lf:AvailableTypes', NS)
        if at_node is not None:
            at = decompile_type(at_node)
            if at:
                obj['availableTypes'] = at
        cbr = get_child(node, 'ChoiceButtonRepresentation')
        if cbr:
            obj['choiceButtonRepresentation'] = cbr
        cbp = get_picture_ref(node, 'ChoiceButtonPicture')
        if cbp is not None:
            obj['choiceButtonPicture'] = cbp
        if get_child(node, 'TextEdit') == 'false':
            obj['textEdit'] = False
        cl = decompile_choice_list(node)
        if cl:
            obj['choiceList'] = cl
        add_format_props(obj, node)
        cp = decompile_choice_parameters(node)
        if cp:
            obj['choiceParameters'] = cp
        cpl = decompile_choice_parameter_links(node)
        if cpl:
            obj['choiceParameterLinks'] = cpl
        tlk = decompile_type_link(node)
        if tlk:
            obj['typeLink'] = tlk
    elif tag == 'CheckBoxField':
        obj[key] = name
        dp = get_child(node, 'DataPath')
        if dp:
            obj['path'] = dp
        add_common_props(obj, node, name)
        em = get_child(node, 'EditMode')
        if em:
            obj['editMode'] = em
        cbt = get_child(node, 'CheckBoxType')
        if cbt is None:
            obj['checkBoxType'] = ''
        elif cbt != 'Auto':
            obj['checkBoxType'] = cbt[0:1].lower() + cbt[1:]
        add_title_location(obj, node, 'Right')
        woe = node.find('lf:WarningOnEdit', NS)
        if woe is not None:
            t = get_lang_text_ws(woe)
            if t is not None:
                obj['warningOnEdit'] = t
        fdp = get_child(node, 'FooterDataPath')
        if fdp:
            obj['footerDataPath'] = fdp
        ftxt = node.find('lf:FooterText', NS)
        if ftxt is not None:
            t = get_lang_text_ws(ftxt)
            if t is not None:
                obj['footerText'] = t
        add_format_props(obj, node)
    elif tag == 'RadioButtonField':
        obj[key] = name
        dp = get_child(node, 'DataPath')
        if dp:
            obj['path'] = dp
        add_common_props(obj, node, name)
        add_title_location(obj, node, 'None')
        em = get_child(node, 'EditMode')
        if em:
            obj['editMode'] = em
        rbt = get_child(node, 'RadioButtonType')
        if rbt:
            obj['radioButtonType'] = rbt
        cc = get_child(node, 'ColumnsCount')
        if cc:
            obj['columnsCount'] = int(cc)
        woe = node.find('lf:WarningOnEdit', NS)
        if woe is not None:
            t = get_lang_text_ws(woe)
            if t is not None:
                obj['warningOnEdit'] = t
        cl = decompile_choice_list(node)
        if cl:
            obj['choiceList'] = cl
    elif tag == 'LabelDecoration':
        obj[key] = name
        add_common_props(obj, node, name)
        if get_child(node, 'Hyperlink') == 'true':
            obj['hyperlink'] = True
        ti_node = node.find('lf:Title', NS)
        if ti_node is not None:
            tv = get_ml_formatted_value(ti_node)
            if tv is not None:
                obj['title'] = tv
    elif tag == 'LabelField':
        obj[key] = name
        dp = get_child(node, 'DataPath')
        if dp:
            obj['path'] = dp
        add_common_props(obj, node, name)
        tl = get_child(node, 'TitleLocation')
        if tl:
            obj['titleLocation'] = tl.lower()
        em = get_child(node, 'EditMode')
        if em:
            obj['editMode'] = em
        if get_child(node, 'Hiperlink') == 'true':   # тег <Hiperlink> (опечатка платформы)
            obj['hyperlink'] = True
        pm = get_child(node, 'PasswordMode')
        if pm is not None:
            obj['passwordMode'] = (pm == 'true')
        woe = node.find('lf:WarningOnEdit', NS)
        if woe is not None:
            t = get_lang_text_ws(woe)
            if t is not None:
                obj['warningOnEdit'] = t
        fdp = get_child(node, 'FooterDataPath')
        if fdp:
            obj['footerDataPath'] = fdp
        ftxt = node.find('lf:FooterText', NS)
        if ftxt is not None:
            t = get_lang_text_ws(ftxt)
            if t is not None:
                obj['footerText'] = t
        add_format_props(obj, node)
    elif tag == 'PictureDecoration':
        obj[key] = name
        add_common_props(obj, node, name)
        ti_node = node.find('lf:Title', NS)
        if ti_node is not None:
            tv = get_ml_formatted_value(ti_node)
            if tv is not None:
                obj['title'] = tv
        npt = node.find('lf:NonselectedPictureText', NS)
        if npt is not None:
            t = get_lang_text_ws(npt)
            if t is not None:
                obj['nonselectedPictureText'] = t
        ref = node.find('lf:Picture/xr:Ref', NS)
        abs_ = node.find('lf:Picture/xr:Abs', NS)
        if ref is not None:
            obj['src'] = _text(ref)
        elif abs_ is not None:
            obj['src'] = 'abs:%s' % _text(abs_)
        lt = node.find('lf:Picture/xr:LoadTransparent', NS)
        if lt is not None and _text(lt) == 'true':
            obj['loadTransparent'] = True
        tpx = node.find('lf:Picture/xr:TransparentPixel', NS)
        if tpx is not None:
            obj['transparentPixel'] = OrderedDict([('x', int(_attr(tpx, 'x'))), ('y', int(_attr(tpx, 'y')))])
        if get_child(node, 'Hyperlink') == 'true':
            obj['hyperlink'] = True
    elif tag == 'PictureField':
        obj[key] = name
        dp = get_child(node, 'DataPath')
        if dp:
            obj['path'] = dp
        add_common_props(obj, node, name)
        em = get_child(node, 'EditMode')
        if em:
            obj['editMode'] = em
        tl = get_child(node, 'TitleLocation')
        if tl:
            obj['titleLocation'] = tl.lower()
        if get_child(node, 'Hyperlink') == 'true':
            obj['hyperlink'] = True
        vp = get_picture_ref(node, 'ValuesPicture')
        if vp is not None:
            obj['valuesPicture'] = vp
        npt = node.find('lf:NonselectedPictureText', NS)
        if npt is not None:
            t = get_lang_text_ws(npt)
            if t is not None:
                obj['nonselectedPictureText'] = t
        fdp = get_child(node, 'FooterDataPath')
        if fdp:
            obj['footerDataPath'] = fdp
        ftxt = node.find('lf:FooterText', NS)
        if ftxt is not None:
            t = get_lang_text_ws(ftxt)
            if t is not None:
                obj['footerText'] = t
    elif tag == 'CalendarField':
        obj[key] = name
        dp = get_child(node, 'DataPath')
        if dp:
            obj['path'] = dp
        add_common_props(obj, node, name)
        tl = get_child(node, 'TitleLocation')
        if tl:
            obj['titleLocation'] = tl.lower()
        sm = get_child(node, 'SelectionMode')
        if sm:
            obj['selectionMode'] = sm
        scd = get_child(node, 'ShowCurrentDate')
        if scd is not None:
            obj['showCurrentDate'] = (scd == 'true')
        wim = get_child(node, 'WidthInMonths')
        if wim is not None:
            obj['widthInMonths'] = int(wim)
        him = get_child(node, 'HeightInMonths')
        if him is not None:
            obj['heightInMonths'] = int(him)
        smp = get_child(node, 'ShowMonthsPanel')
        if smp is not None:
            obj['showMonthsPanel'] = (smp == 'true')
    elif tag == 'Table':
        obj[key] = name
        dp = get_child(node, 'DataPath')
        if dp:
            obj['path'] = dp
        add_common_props(obj, node, name)
        tl = get_child(node, 'TitleLocation')
        if tl:
            obj['titleLocation'] = tl.lower()
        rep = get_child(node, 'Representation')
        if rep:
            obj['representation'] = rep
        crs = get_child(node, 'ChangeRowSet')
        if crs is not None:
            obj['changeRowSet'] = (crs == 'true')
        cro = get_child(node, 'ChangeRowOrder')
        if cro is not None:
            obj['changeRowOrder'] = (cro == 'true')
        if get_child(node, 'AutoInsertNewRow') == 'true':
            obj['autoInsertNewRow'] = True
        if node.find('lf:RowFilter', NS) is not None:
            obj['rowFilter'] = None
        if get_child(node, 'Header') == 'false':
            obj['header'] = False
        if get_child(node, 'Footer') == 'true':
            obj['footer'] = True
        htr = get_child(node, 'HeightInTableRows')
        if htr:
            obj['heightInTableRows'] = int(htr)
        hh = get_child(node, 'HeaderHeight')
        if hh is not None:
            obj['headerHeight'] = int(hh)
        fh = get_child(node, 'FooterHeight')
        if fh is not None:
            obj['footerHeight'] = int(fh)
        cru = get_child(node, 'CurrentRowUse')
        if cru:
            obj['currentRowUse'] = cru
        rr = get_child(node, 'RefreshRequest')
        if rr:
            obj['refreshRequest'] = rr
        # CommandBarLocation: дин-список-таблица авто-инжектит "None" → инвертируем суппресс-маркером.
        cbl = get_child(node, 'CommandBarLocation')
        if has_child(node, 'UpdateOnDataChange'):
            if cbl is None:
                obj['commandBarLocation'] = ''
            elif cbl != 'None':
                obj['commandBarLocation'] = cbl
        elif cbl:
            obj['commandBarLocation'] = cbl
        ssl = get_child(node, 'SearchStringLocation')
        if ssl:
            obj['searchStringLocation'] = ssl
        vsl = get_child(node, 'ViewStatusLocation')
        if vsl:
            obj['viewStatusLocation'] = vsl
        scl = get_child(node, 'SearchControlLocation')
        if scl:
            obj['searchControlLocation'] = scl
        if get_child(node, 'ChoiceMode') == 'true':
            obj['choiceMode'] = True
        selm = get_child(node, 'SelectionMode')
        if selm:
            obj['selectionMode'] = selm
        rsm = get_child(node, 'RowSelectionMode')
        if rsm:
            obj['rowSelectionMode'] = rsm
        if get_child(node, 'VerticalLines') == 'false':
            obj['verticalLines'] = False
        if get_child(node, 'HorizontalLines') == 'false':
            obj['horizontalLines'] = False
        if get_child(node, 'UseAlternationRowColor') == 'true':
            obj['useAlternationRowColor'] = True
        taf = get_child(node, 'Autofill')
        if taf is not None:
            obj['autofill'] = (taf == 'true')
        if get_child(node, 'MultipleChoice') == 'true':
            obj['multipleChoice'] = True
        soin = get_child(node, 'SearchOnInput')
        if soin:
            obj['searchOnInput'] = soin
        mi = get_child(node, 'AutoMarkIncomplete')
        if mi is not None:
            obj['markIncomplete'] = (mi == 'true')
        itv = get_child(node, 'InitialTreeView')
        if itv:
            obj['initialTreeView'] = itv
        rp = get_picture_ref(node, 'RowsPicture')
        if rp is not None:
            obj['rowsPicture'] = rp
        rpdp = get_child(node, 'RowPictureDataPath')
        if has_child(node, 'UpdateOnDataChange'):
            if get_child(node, 'AutoRefresh') == 'true':
                obj['autoRefresh'] = True
            arp = get_child(node, 'AutoRefreshPeriod')
            if arp and arp != '60':
                obj['autoRefreshPeriod'] = int(arp)
            cfi = get_child(node, 'ChoiceFoldersAndItems')
            if cfi and cfi != 'Items':
                obj['choiceFoldersAndItems'] = cfi
            if get_child(node, 'RestoreCurrentRow') == 'true':
                obj['restoreCurrentRow'] = True
            if get_child(node, 'ShowRoot') == 'false':
                obj['showRoot'] = False
            if get_child(node, 'AllowRootChoice') == 'true':
                obj['allowRootChoice'] = True
            uodc = get_child(node, 'UpdateOnDataChange')
            if uodc and uodc != 'Auto':
                obj['updateOnDataChange'] = uodc
            if get_child(node, 'AllowGettingCurrentRowURL') == 'false':
                obj['allowGettingCurrentRowURL'] = False
            if rpdp is None:
                obj['rowPictureDataPath'] = ''
            elif rpdp != ('%s.DefaultPicture' % _ps_str(obj.get('path'))):
                obj['rowPictureDataPath'] = rpdp
            usg = get_child(node, 'UserSettingsGroup')
            if usg:
                if re.match(r'^\d+:[0-9a-fA-F]{8}-', usg):
                    sys.stderr.write("form-decompile: UserSettingsGroup '%s' (%s) — ссылка по id, не воспроизводима, опущена\n" % (usg, name))
                else:
                    obj['userSettingsGroup'] = usg
        elif rpdp:
            obj['rowPictureDataPath'] = rpdp
        cs_node = node.find('lf:CommandSet', NS)
        if cs_node is not None:
            exc = []
            for ec in cs_node.findall('lf:ExcludedCommand', NS):
                exc.append(_text(ec))
            if len(exc) > 0:
                obj['excludedCommands'] = exc
        cols = decompile_children(node)
        if cols:
            obj['columns'] = cols
        add_map = decompile_table_additions(node, name)
        if add_map:
            obj['additions'] = add_map
    elif tag == 'Pages':
        obj[key] = name
        add_common_props(obj, node, name)
        pr = get_child(node, 'PagesRepresentation')
        if pr:
            obj['pagesRepresentation'] = pr
        cru = get_child(node, 'CurrentRowUse')
        if cru:
            obj['currentRowUse'] = cru
        kids = decompile_children(node)
        if kids:
            obj['children'] = kids
    elif tag == 'Page':
        obj[key] = name
        add_common_props(obj, node, name)
        g = get_child(node, 'Group')
        gmap = {'Horizontal': 'horizontal', 'Vertical': 'vertical', 'AlwaysHorizontal': 'alwaysHorizontal', 'AlwaysVertical': 'alwaysVertical', 'HorizontalIfPossible': 'horizontalIfPossible'}
        if g and g in gmap:
            obj['group'] = gmap[g]
        pp = get_picture_ref(node, 'Picture')
        if pp is not None:
            obj['picture'] = pp
        st = get_child(node, 'ShowTitle')
        if st is not None:
            obj['showTitle'] = (st == 'true')
        add_format_props(obj, node)
        kids = decompile_children(node)
        if kids:
            obj['children'] = kids
    elif tag == 'Button':
        obj[key] = name
        cmd = get_child(node, 'CommandName')
        if cmd:
            m1 = re.match(r'^Form\.Command\.(.+)$', cmd)
            m2 = re.match(r'^Form\.StandardCommand\.(.+)$', cmd)
            m3 = re.match(r'^Form\.Item\.(.+)\.StandardCommand\.(.+)$', cmd)
            if m1:
                obj['command'] = m1.group(1)
            elif m2:
                obj['stdCommand'] = m2.group(1)
            elif m3:
                obj['stdCommand'] = '%s.%s' % (m3.group(1), m3.group(2))
            else:
                obj['commandName'] = cmd
        dp = get_child(node, 'DataPath')
        if dp:
            obj['path'] = dp
        btn_param = node.find('lf:Parameter', NS)
        if btn_param is not None:
            pxt = _attr(btn_param, 'type', NS_XSI)
            if re.search(r'TypeDescription$', pxt):
                pt = decompile_type(btn_param)
                if pt:
                    obj['parameter'] = OrderedDict([('type', pt)])
            elif _text(btn_param):
                obj['parameter'] = _text(btn_param)
        add_common_props(obj, node, name)
        type_ = get_child(node, 'Type')
        if type_:
            tmap = {'CommandBarButton': 'commandBar', 'UsualButton': 'usual', 'Hyperlink': 'hyperlink', 'CommandBarHyperlink': 'hyperlink'}
            obj['type'] = tmap[type_] if type_ in tmap else type_
        if get_child(node, 'DefaultButton') == 'true':
            obj['defaultButton'] = True
        if get_child(node, 'Check') == 'true':
            obj['checked'] = True
        set_command_picture(obj, node)
        rep = get_child(node, 'Representation')
        if rep:
            obj['representation'] = rep
        lic = get_child(node, 'LocationInCommandBar')
        if lic:
            obj['locationInCommandBar'] = lic
    elif tag == 'ButtonGroup':
        obj[key] = name
        add_common_props(obj, node, name)
        cs = get_child(node, 'CommandSource')
        if cs:
            if re.match(r'^\d+:[0-9a-fA-F]{8}-', cs):
                sys.stderr.write("form-decompile: CommandSource '%s' (%s) — ссылка по id, не воспроизводима, опущена\n" % (cs, name))
            else:
                obj['commandSource'] = cs
        rep = get_child(node, 'Representation')
        if rep:
            obj['representation'] = rep
        kids = decompile_children(node)
        if kids:
            obj['children'] = kids
    elif tag == 'CommandBar':
        obj[key] = name
        add_common_props(obj, node, name)
        cs = get_child(node, 'CommandSource')
        if cs:
            if re.match(r'^\d+:[0-9a-fA-F]{8}-', cs):
                sys.stderr.write("form-decompile: CommandSource '%s' (%s) — ссылка по id, не воспроизводима, опущена\n" % (cs, name))
            else:
                obj['commandSource'] = cs
        hl = get_child(node, 'HorizontalLocation')
        if hl:
            obj['horizontalLocation'] = hl.lower()
        if get_child(node, 'Autofill') == 'true':
            obj['autofill'] = True
        kids = decompile_children(node)
        if kids:
            obj['children'] = kids
    elif tag == 'Popup':
        obj[key] = name
        add_common_props(obj, node, name)
        set_command_picture(obj, node)
        rep = get_child(node, 'Representation')
        if rep:
            obj['representation'] = rep
        cs = get_child(node, 'CommandSource')
        if cs:
            if re.match(r'^\d+:[0-9a-fA-F]{8}-', cs):
                sys.stderr.write("form-decompile: CommandSource '%s' (%s) — ссылка по id, не воспроизводима, опущена\n" % (cs, name))
            else:
                obj['commandSource'] = cs
        kids = decompile_children(node)
        if kids:
            obj['children'] = kids
    elif tag == 'SearchStringAddition':
        obj[key] = name
        add_addition_core(obj, node, name)
    elif tag == 'ViewStatusAddition':
        obj[key] = name
        add_addition_core(obj, node, name)
    elif tag == 'SearchControlAddition':
        obj[key] = name
        add_addition_core(obj, node, name)
    elif tag == 'SpreadSheetDocumentField':
        decompile_simple_field(obj, node, name, key)
    elif tag == 'HTMLDocumentField':
        decompile_simple_field(obj, node, name, key)
    elif tag == 'TextDocumentField':
        decompile_simple_field(obj, node, name, key)
    elif tag == 'FormattedDocumentField':
        decompile_simple_field(obj, node, name, key)
    elif tag == 'ProgressBarField':
        decompile_simple_field(obj, node, name, key)
        add_gauge_scalars(obj, node, ('MinValue', 'MaxValue'))
    elif tag == 'TrackBarField':
        decompile_simple_field(obj, node, name, key)
        add_gauge_scalars(obj, node, ('MinValue', 'MaxValue', 'LargeStep', 'MarkingStep', 'Step'))
    elif tag == 'ChartField':
        decompile_simple_field(obj, node, name, key)
    elif tag == 'GraphicalSchemaField':
        decompile_simple_field(obj, node, name, key)
    elif tag == 'PlannerField':
        decompile_simple_field(obj, node, name, key)
    elif tag == 'PeriodField':
        decompile_simple_field(obj, node, name, key)
    elif tag == 'DendrogramField':
        decompile_simple_field(obj, node, name, key)
    elif tag == 'GanttChartField':
        decompile_simple_field(obj, node, name, key)
        tbl_node = node.find('lf:Table', NS)
        if tbl_node is not None:
            obj['ganttTable'] = decompile_element(tbl_node)

    # DisplayImportance — атрибут открывающего тега, захват «как есть».
    di = _attr(node, 'DisplayImportance')
    if di:
        obj['displayImportance'] = di
    # title: "" — подавление авто-вывода компилятора там, где <Title> отсутствует.
    if 'title' not in obj:
        auto_title = False
        if tag in ('LabelDecoration', 'Page', 'Popup'):
            auto_title = True
        elif tag == 'Button':
            auto_title = not ('command' in obj or 'commandName' in obj or 'stdCommand' in obj)
        elif tag in ('InputField', 'CheckBoxField', 'RadioButtonField', 'LabelField', 'Table', 'CalendarField'):
            auto_title = 'path' not in obj
        if auto_title:
            obj['title'] = ''
    add_layout(obj, node)
    add_generic_scalars(obj, node)
    # extendedTooltip: companion <ExtendedTooltip> (LabelDecoration). Текст-форма или own-content объект.
    et_node = node.find('lf:ExtendedTooltip', NS)
    if et_node is not None:
        et_title = et_node.find('lf:Title', NS)
        text_val = get_ml_formatted_value(et_title) if et_title is not None else None
        et_obj = OrderedDict()
        add_layout(et_obj, et_node)
        add_generic_scalars(et_obj, et_node)
        add_appearance(et_obj, et_node)
        et_tt = et_node.find('lf:ToolTip', NS)
        if et_tt is not None:
            tt_val = get_lang_text(et_tt)
            if tt_val is not None:
                et_obj['tooltip'] = tt_val
        if get_child(et_node, 'Visible') == 'false':
            et_obj['hidden'] = True
        if get_child(et_node, 'Enabled') == 'false':
            et_obj['disabled'] = True
        if get_child(et_node, 'Hyperlink') == 'true':
            et_obj['hyperlink'] = True
        et_ev = get_events(et_node, name)
        if et_ev:
            et_obj['events'] = et_ev
        if len(et_obj) > 0:
            if text_val is not None:
                if isinstance(text_val, dict) and 'text' in text_val:
                    et_obj['text'] = text_val['text']
                    if text_val['formatted']:
                        et_obj['formatted'] = True
                else:
                    et_obj['text'] = text_val
                if 'formatted' not in et_obj and et_title is not None and _attr(et_title, 'formatted') == 'true':
                    et_obj['formatted'] = True
            obj['extendedTooltip'] = et_obj
        elif text_val is not None:
            obj['extendedTooltip'] = text_val
    # companion-панели с контентом: AutoCommandBar → commandBar, ContextMenu → contextMenu
    is_dyn_list_table = (tag == 'Table') and has_child(node, 'UpdateOnDataChange')
    cb = decompile_companion_panel(node, 'AutoCommandBar', is_dyn_list_table)
    if cb is not None:
        obj['commandBar'] = cb
    cm = decompile_companion_panel(node, 'ContextMenu')
    if cm is not None:
        obj['contextMenu'] = cm
    return obj


# ─────────────────────────────────────────────────────────────────────────────
# Planner design-time <Settings xsi:type="pl:Planner"> → объект planner на реквизите.
def pld_bool(v):
    if v is None:
        return None
    return v == 'true'


def pld_int(v):
    if v is None:
        return None
    return int(v)


def get_planner_value(node):
    if node is None:
        return None
    if _attr(node, 'nil', NS_XSI) == 'true':
        return None
    t = _text(node)
    if t:
        return t
    return None


def build_planner_font(node):
    if node is None:
        return None
    o = OrderedDict()
    for a in ('ref', 'faceName', 'height', 'bold', 'italic', 'underline', 'strikeout', 'kind', 'scale'):
        av = _attr(node, a)
        if av != '':
            o[a] = av
    if len(o) == 0:
        return None
    return o


def build_planner_border(node):
    if node is None:
        return None
    o = OrderedDict()
    w = _attr(node, 'width')
    if w != '':
        o['width'] = int(w)
    st = node.find('{*}style')
    if st is not None:
        o['style'] = _text(st)
    return o


def build_planner_item(itn):
    o = OrderedDict()
    val_node = itn.find('{*}value')
    if val_node is not None and _attr(val_node, 'nil', NS_XSI) != 'true' and _text(val_node):
        o['value'] = _text(val_node)
    o['text'] = get_child(itn, 'text')
    tt = get_child(itn, 'tooltip')
    if tt:
        o['tooltip'] = tt
    o['begin'] = get_child(itn, 'begin')
    o['end'] = get_child(itn, 'end')
    o['borderColor'] = get_child(itn, 'borderColor')
    o['backColor'] = get_child(itn, 'backColor')
    o['textColor'] = get_child(itn, 'textColor')
    fnt = build_planner_font(itn.find('{*}font'))
    if fnt:
        o['font'] = fnt
    o['replacementDate'] = get_child(itn, 'replacementDate')
    o['deleted'] = pld_bool(get_child(itn, 'deleted'))
    o['id'] = get_child(itn, 'id')
    o['textFormatted'] = pld_bool(get_child(itn, 'textFormatted'))
    brd = build_planner_border(itn.find('{*}border'))
    if brd:
        o['border'] = brd
    o['editMode'] = get_child(itn, 'editMode')
    return o


def build_planner_dim_element(eln):
    o = OrderedDict()
    v = get_planner_value(eln.find('{*}value'))
    if v is not None:
        o['value'] = v
    o['text'] = get_child(eln, 'text')
    o['borderColor'] = get_child(eln, 'borderColor')
    o['backColor'] = get_child(eln, 'backColor')
    o['textColor'] = get_child(eln, 'textColor')
    fnt = build_planner_font(eln.find('{*}font'))
    if fnt:
        o['font'] = fnt
    subs = []
    for s in eln.findall('{*}item'):
        subs.append(build_planner_dim_element(s))
    if len(subs) > 0:
        o['elements'] = subs
    sos = get_child(eln, 'showOnlySubordinatesAreas')
    if sos is not None:
        o['showOnlySubordinatesAreas'] = (sos == 'true')
    o['textFormatted'] = pld_bool(get_child(eln, 'textFormatted'))
    return o


def build_planner_dimension(dn):
    o = OrderedDict()
    v = get_planner_value(dn.find('{*}value'))
    if v is not None:
        o['value'] = v
    o['text'] = get_child(dn, 'text')
    o['borderColor'] = get_child(dn, 'borderColor')
    o['backColor'] = get_child(dn, 'backColor')
    o['textColor'] = get_child(dn, 'textColor')
    fnt = build_planner_font(dn.find('{*}font'))
    if fnt:
        o['font'] = fnt
    els = []
    for e in dn.findall('{*}item'):
        els.append(build_planner_dim_element(e))
    if len(els) > 0:
        o['elements'] = els
    o['textFormatted'] = pld_bool(get_child(dn, 'textFormatted'))
    return o


def build_planner_level(lvn):
    o = OrderedDict()
    o['measure'] = get_child(lvn, 'measure')
    o['interval'] = pld_int(get_child(lvn, 'interval'))
    o['show'] = pld_bool(get_child(lvn, 'show'))
    line_node = lvn.find('{*}line')
    if line_node is not None:
        ln = OrderedDict()
        w = _attr(line_node, 'width')
        if w != '':
            ln['width'] = int(w)
        g = _attr(line_node, 'gap')
        if g != '':
            ln['gap'] = (g == 'true')
        st = line_node.find('{*}style')
        if st is not None:
            ln['style'] = _text(st)
        o['line'] = ln
    o['scaleColor'] = get_child(lvn, 'scaleColor')
    o['dayFormatRule'] = get_child(lvn, 'dayFormatRule')
    fmt_node = lvn.find('{*}format')
    if fmt_node is not None:
        f = get_lang_text(fmt_node)
        if f is not None:
            o['format'] = f
    labels_node = lvn.find('{*}labels')
    if labels_node is not None:
        o['labels'] = OrderedDict([('ticks', pld_int(get_child(labels_node, 'ticks')))])
    o['backColor'] = get_child(lvn, 'backColor')
    o['textColor'] = get_child(lvn, 'textColor')
    o['showPereodicalLabels'] = pld_bool(get_child(lvn, 'showPereodicalLabels'))
    return o


def build_planner_time_scale(tsn):
    o = OrderedDict()
    o['placement'] = get_child(tsn, 'placement')
    levels = []
    for lvn in tsn.findall('{*}level'):
        levels.append(build_planner_level(lvn))
    o['levels'] = levels
    o['transparent'] = pld_bool(get_child(tsn, 'transparent'))
    o['backColor'] = get_child(tsn, 'backColor')
    o['textColor'] = get_child(tsn, 'textColor')
    o['currentLevel'] = pld_int(get_child(tsn, 'currentLevel'))
    return o


def build_planner_settings(set_node):
    pl = OrderedDict()
    item_nodes = set_node.findall('{*}item')
    if len(item_nodes) > 0:
        items = []
        for itn in item_nodes:
            items.append(build_planner_item(itn))
        pl['items'] = items
    dim_nodes = set_node.findall('{*}dimension')
    if len(dim_nodes) > 0:
        dims = []
        for dn in dim_nodes:
            dims.append(build_planner_dimension(dn))
        pl['dimensions'] = dims
    pl['borderColor'] = get_child(set_node, 'borderColor')
    pl['backColor'] = get_child(set_node, 'backColor')
    pl['textColor'] = get_child(set_node, 'textColor')
    pl['lineColor'] = get_child(set_node, 'lineColor')
    fnt = build_planner_font(set_node.find('{*}font'))
    if fnt:
        pl['font'] = fnt
    pl['beginOfRepresentationPeriod'] = get_child(set_node, 'beginOfRepresentationPeriod')
    pl['endOfRepresentationPeriod'] = get_child(set_node, 'endOfRepresentationPeriod')
    pl['alignElementsOfTimeScale'] = pld_bool(get_child(set_node, 'alignElementsOfTimeScale'))
    pl['displayTimeScaleWrapHeaders'] = pld_bool(get_child(set_node, 'displayTimeScaleWrapHeaders'))
    pl['displayWrapHeaders'] = pld_bool(get_child(set_node, 'displayWrapHeaders'))
    wf_node = set_node.find('{*}timeScaleWrapHeadersFormat')
    if wf_node is not None:
        wf = get_lang_text(wf_node)
        if wf is not None:
            pl['timeScaleWrapHeadersFormat'] = wf
    pl['periodicVariantUnit'] = get_child(set_node, 'periodicVariantUnit')
    pl['periodicVariantRepetition'] = pld_int(get_child(set_node, 'periodicVariantRepetition'))
    pl['timeScaleWrapBeginIndent'] = pld_int(get_child(set_node, 'timeScaleWrapBeginIndent'))
    pl['timeScaleWrapEndIndent'] = pld_int(get_child(set_node, 'timeScaleWrapEndIndent'))
    ts_node = set_node.find('{*}timeScale')
    if ts_node is not None:
        pl['timeScale'] = build_planner_time_scale(ts_node)
    per_node = set_node.find('{*}period')
    if per_node is not None:
        pl['period'] = OrderedDict([('begin', get_child(per_node, 'begin')), ('end', get_child(per_node, 'end'))])
    pl['displayCurrentDate'] = pld_bool(get_child(set_node, 'displayCurrentDate'))
    pl['itemsTimeRepresentation'] = get_child(set_node, 'itemsTimeRepresentation')
    pl['itemsBehaviorWhenSpaceInsufficient'] = get_child(set_node, 'itemsBehaviorWhenSpaceInsufficient')
    pl['autoMinColumnWidth'] = pld_bool(get_child(set_node, 'autoMinColumnWidth'))
    pl['autoMinRowHeight'] = pld_bool(get_child(set_node, 'autoMinRowHeight'))
    pl['minColumnWidth'] = pld_int(get_child(set_node, 'minColumnWidth'))
    pl['minRowHeight'] = pld_int(get_child(set_node, 'minRowHeight'))
    pl['fixDimensionsHeader'] = get_child(set_node, 'fixDimensionsHeader')
    pl['fixTimeScaleHeader'] = get_child(set_node, 'fixTimeScaleHeader')
    brd = build_planner_border(set_node.find('{*}border'))
    if brd:
        pl['border'] = brd
    pl['newItemsTextType'] = get_child(set_node, 'newItemsTextType')
    return pl


# ─────────────────────────────────────────────────────────────────────────────
# Chart design-time <Settings xsi:type="d4p1:Chart"> → объект chart (генерик-движок).
CHART_ML_FIELDS = {'title', 'lbFormat', 'lbpFormat', 'vsFormat', 'dtFormat', 'dataSourceDescription', 'labelFormat', 'text'}
CHART_SERIES_FIELDS = {'realSeriesData', 'realExSeriesData', 'realPointData', 'realDataItems'}
CHART_ATTR_FIELDS = {'gaugeQualityBands'}


def conv_chart_scalar(v):
    if v == 'true':
        return True
    if v == 'false':
        return False
    return v


def build_chart_node(n, name):
    # ML-поле → строка/мапа/"" (даже ru-only форсим в ML на эмите по имени)
    if name in CHART_ML_FIELDS:
        ml = get_lang_text(n)
        if ml is None:
            return ''
        return ml
    kids = list(n)
    if len(kids) == 0:
        # лист: attrs-only (шрифт/gaugeQualityBands) или текст
        attrs = [(k, v) for k, v in n.attrib.items() if k != _XSI_TYPE and k != ('{%s}nil' % NS_XSI)]
        if len(attrs) > 0:
            o = OrderedDict()
            for k, v in attrs:
                o[k] = conv_chart_scalar(v)
            return o
        return conv_chart_scalar(_text(n))
    # line/border: дочерний v8ui:style (+ width[/gap])
    style_child = n.find('{*}style')
    if style_child is not None:
        o = OrderedDict()
        w = _attr(n, 'width')
        if w != '':
            o['width'] = int(w)
        g = _attr(n, 'gap')
        if g != '':
            o['gap'] = (g == 'true')
        o['style'] = _text(style_child)
        return o
    # вложенный объект d4p1: группируем детей по имени
    o = OrderedDict()
    for c in kids:
        ln = _local_name(c.tag)
        val = build_chart_node(c, ln)
        if ln in CHART_SERIES_FIELDS:
            if ln not in o:
                o[ln] = []
            o[ln].append(val)
        elif ln in o:
            if not isinstance(o[ln], list):
                o[ln] = [o[ln]]
            o[ln].append(val)
        else:
            o[ln] = val
    return o


def build_chart_settings(set_node):
    return build_chart_node(set_node, '')


# Зеркало компилятор-эвристики B3: есть ли cmdBar-элемент где-либо в дереве.
def test_any_cmd_bar(lst):
    if not lst:
        return False
    for e in lst:
        if isinstance(e, dict) and 'cmdBar' in e:
            return True
        if isinstance(e, dict):
            if 'children' in e and test_any_cmd_bar(e['children']):
                return True
            if 'columns' in e and test_any_cmd_bar(e['columns']):
                return True
    return False


# Объектный тип (зеркало Test-IsObjectLikeType) — кандидат на авто-main эвристики 11b.3.
def test_is_object_like_type_dec(type_):
    if not type_:
        return False
    if type_ == 'DynamicList' or type_ == 'ConstantsSet':
        return True
    return bool(re.match(r'^(CatalogObject|DocumentObject|DataProcessorObject|ReportObject|ExternalDataProcessorObject|ExternalReportObject|BusinessProcessObject|TaskObject|ChartOfAccountsObject|ChartOfCharacteristicTypesObject|ChartOfCalculationTypesObject|ExchangePlanObject|InformationRegisterRecordSet|AccumulationRegisterRecordSet|AccountingRegisterRecordSet|CalculationRegisterRecordSet|InformationRegisterRecordManager)\.', type_))


# Ring 3: конструкции вне зоны поддержки (зеркало inline-скана канона 219-235).
def _ring3_scan(root, form_path):
    # ConditionalAppearance со scope (привязка к области) пока не воспроизводим.
    for ca in root.iter():
        if _local_name(ca.tag) != 'ConditionalAppearance':
            continue
        for item in list(ca):
            if _local_name(item.tag) != 'item':
                continue
            for scope in list(item):
                if _local_name(scope.tag) != 'scope':
                    continue
                if len(scope) > 0 or (scope.text or '').strip():
                    fail_ring3("ConditionalAppearance со scope", "form/ConditionalAppearance/item/scope")
    # Реквизит с design-time <Settings> chart-типа (кроме TypeDescription/DynamicList/Planner/Chart).
    for attr in root.iter():
        if _local_name(attr.tag) != 'Attribute':
            continue
        for s in list(attr):
            if _local_name(s.tag) != 'Settings':
                continue
            st = _attr(s, 'type', NS_XSI)
            if st and not re.search(r'TypeDescription$', st) and not re.search(r'DynamicList$', st) and not re.search(r'Planner$', st) and not re.search(r'd4p1:(Gantt)?Chart$', st):
                fail_ring3("Attribute>Settings типа '%s' (design-time конфигурация, напр. диаграмма)" % st, "Attribute/Settings")
            elif re.search(r'd4p1:(Gantt)?Chart$', st):
                # Chart/GanttChart с типизированными значениями/осями/точками (d4p1 xsi:type/nil/item).
                chart_uri = NSMAP_DOC.get('d4p1')
                typed = False
                if chart_uri:
                    pref = '{%s}' % chart_uri
                    nil_key = '{%s}nil' % NS_XSI
                    for d in s.iter():
                        if not d.tag.startswith(pref):
                            continue
                        if _XSI_TYPE in d.attrib or nil_key in d.attrib or _local_name(d.tag) == 'item':
                            typed = True
                            break
                if typed:
                    fail_ring3("Attribute>Settings %s с точками/осями (типизированные значения/d4p1-ML)" % st, "Attribute/Settings")


# ═══════════════════════════════════════════════════════════════════════════
# MAIN
# ═══════════════════════════════════════════════════════════════════════════

def main():
    global ROOT, NSMAP_DOC, OUTPUT_DIR, OUTPUT_BASENAME, QUERY_FILES_ACCUMULATOR, QUERY_FILE_NAMES_USED
    parser = argparse.ArgumentParser(description='Decompile 1C managed Form.xml to JSON DSL', allow_abbrev=False)
    parser.add_argument('-FormPath', '-Path', dest='FormPath', type=str, required=True)
    parser.add_argument('-OutputPath', dest='OutputPath', type=str, default=None)
    args = parser.parse_args()

    form_path = args.FormPath
    output_path = args.OutputPath

    # --- 0. Resolve and validate input ---
    if not os.path.exists(form_path):
        sys.stderr.write("Form not found: %s\n" % form_path)
        sys.exit(1)
    form_path = os.path.abspath(form_path)

    # Префикс→URI (для ring3-проверки d4p1-чартов). Первое связывание на префикс.
    NSMAP_DOC = {}
    for _ev, (_pfx, _uri) in ET.iterparse(form_path, events=['start-ns']):
        if _pfx not in NSMAP_DOC:
            NSMAP_DOC[_pfx] = _uri

    # .NET XmlDocument сохраняет литеральные \r\n в InnerText; ET (expat) нормализует CRLF→LF
    # по XML-спеке. Чтобы совпасть с каноном, превращаем \r\n→&#13;\n (символьные ссылки не
    # подлежат EOL-нормализации) в содержимом документа — но только от <Form (в прологе char-ref
    # невалиден). Покрывает многострочные title/tooltip/content/QueryText.
    raw = open(form_path, 'rb').read()
    rs = raw.find(b'<Form')
    re_end = raw.rfind(b'</Form>')
    if rs >= 0 and re_end >= 0:
        end = re_end + len(b'</Form>')
        # Только ВНУТРИ корневого элемента: в прологе/эпилоге char-ref невалиден (хвостовой </Form>\r\n).
        raw = raw[:rs] + raw[rs:end].replace(b'\r\n', b'&#13;\n') + raw[end:]
    root = ET.fromstring(raw)
    ROOT = root

    # Ring 2: not a managed Form
    if _local_name(root.tag) != 'Form':
        sys.stderr.write("form-decompile: корневой элемент <%s> не <Form> — это не управляемая форма.\n" % _local_name(root.tag))
        sys.exit(2)

    # --- Вынос запроса динсписка в .sql рядом с output ---
    QUERY_FILES_ACCUMULATOR = []
    QUERY_FILE_NAMES_USED = {}
    if output_path:
        od = os.path.dirname(output_path)
        if not od:
            od = os.getcwd()
        OUTPUT_DIR = od
        OUTPUT_BASENAME = os.path.splitext(os.path.basename(output_path))[0]

    # --- 1b. Ring-3 scan ---
    _ring3_scan(root, form_path)

    # --- 5. Form-level assembly ---
    dsl = OrderedDict()

    title_node = root.find('lf:Title', NS)
    if title_node is not None:
        t = get_lang_text(title_node)
        if t is not None:
            dsl['title'] = t

    # properties (прямые скаляры под <Form>, PascalCase → camelCase)
    known_form_props = ['AutoTitle', 'ReportResult', 'DetailsData', 'ReportFormType', 'AutoShowState', 'ReportResultViewMode', 'ViewModeApplicationOnSetReportResult', 'WindowOpeningMode', 'CommandBarLocation', 'SaveDataInSettings', 'AutoSaveDataInSettings', 'AutoTime', 'UsePostingMode', 'RepostOnWrite', 'AutoURL', 'AutoFillCheck', 'Customizable', 'EnterKeyBehavior', 'VerticalScroll', 'Width', 'Height', 'Group', 'UseForFoldersAndItems', 'SaveWindowSettings', 'ScalingMode', 'VerticalSpacing', 'VariantAppearance', 'ShowCloseButton', 'HorizontalAlign', 'ChildrenAlign', 'ShowTitle', 'ConversationsRepresentation', 'CollapseItemsByImportanceVariant', 'GroupList', 'ChildItemsWidth', 'VerticalAlign', 'HorizontalSpacing', 'CustomSettingsFolder', 'SettingsStorage', 'Enabled', 'Scale']
    props = OrderedDict()
    for pn in known_form_props:
        v = get_child(root, pn)
        if v is not None:
            camel = pn[0:1].lower() + pn[1:]
            if v == 'true':
                props[camel] = True
            elif v == 'false':
                props[camel] = False
            elif re.match(r'^\d+$', v):
                props[camel] = int(v)
            else:
                props[camel] = v
    # Ссылка на члена формы по id ("N:uuid") в groupList/customSettingsFolder НЕ воспроизводима.
    for ref_key in ('groupList', 'customSettingsFolder'):
        if ref_key in props and re.match(r'^\d+:[0-9a-fA-F]{8}-', _ps_str(props[ref_key])):
            sys.stderr.write("form-decompile: %s = '%s' — ссылка на члена формы по id, не воспроизводима (id переназначаются), опущена. Задайте по имени через form-edit.\n" % (ref_key, props[ref_key]))
            del props[ref_key]
    # AutoTitle при наличии title: компилятор инъектит false (~95%). Зеркалим.
    if 'title' in dsl:
        if 'autoTitle' not in props:
            props['autoTitle'] = ''
        elif props['autoTitle'] is False:
            del props['autoTitle']
    if len(props) > 0:
        dsl['properties'] = props

    # MobileDeviceCommandBarContent (form-level) → список имён
    mdcb = root.find('lf:MobileDeviceCommandBarContent', NS)
    if mdcb is not None:
        names = []
        for it in mdcb.findall('xr:Item', NS):
            v = it.find('xr:Value', NS)
            if v is not None:
                names.append(_text(v))
        if len(names) > 0:
            dsl['mobileCommandBarContent'] = names

    # excludedCommands (form-level <CommandSet>)
    cs_form = root.find('lf:CommandSet', NS)
    if cs_form is not None:
        exc_form = []
        for ec in cs_form.findall('lf:ExcludedCommand', NS):
            exc_form.append(_text(ec))
        if len(exc_form) > 0:
            dsl['excludedCommands'] = exc_form

    # events (form-level) → {Event: handler} напрямую
    ev_form = get_events(root, None)
    if ev_form:
        ev_map = OrderedDict()
        ev_node = root.find('lf:Events', NS)
        for e in ev_node.findall('lf:Event', NS):
            ev_map[_attr(e, 'name')] = _text(e)
        if len(ev_map) > 0:
            dsl['events'] = ev_map

    # elements (+ форменный AutoCommandBar как autoCmdBar-элемент)
    elem_list = []
    elements = decompile_children(root)
    form_has_cmd_bar = test_any_cmd_bar(elements)
    acb = root.find('lf:AutoCommandBar', NS)
    if acb is not None:
        haln = get_child(acb, 'HorizontalAlign')
        acb_autofill = get_child(acb, 'Autofill')
        acb_di = _attr(acb, 'DisplayImportance')
        acb_kids = decompile_children(acb)
        acb_obj = None
        if haln or (acb_autofill == 'false') or acb_kids or acb_di:
            acb_obj = OrderedDict()
            acb_obj['autoCmdBar'] = _attr(acb, 'name')
            if acb_di:
                acb_obj['displayImportance'] = acb_di
            if haln:
                acb_obj['horizontalAlign'] = haln
            if acb_autofill == 'false':
                acb_obj['autofill'] = False
            if acb_kids:
                acb_obj['children'] = acb_kids
        elif form_has_cmd_bar and acb_autofill is None:
            acb_obj = OrderedDict()
            acb_obj['autoCmdBar'] = _attr(acb, 'name')
            acb_obj['autofill'] = True
        if acb_obj is not None:
            elem_list.append(acb_obj)
    if elements:
        for e in elements:
            elem_list.append(e)
    if len(elem_list) > 0:
        dsl['elements'] = elem_list

    # attributes
    attrs_node = root.find('lf:Attributes', NS)
    if attrs_node is not None:
        attrs = []
        # Подавление авто-main (эвристика 11b.3): нет <MainAttribute> И ровно 1 объектный реквизит.
        all_attr_nodes = attrs_node.findall('lf:Attribute', NS)
        any_main_attr = False
        obj_like_nodes = []
        for an in all_attr_nodes:
            if get_child(an, 'MainAttribute') == 'true':
                any_main_attr = True
            atype = decompile_type(an.find('lf:Type', NS))
            if test_is_object_like_type_dec(_ps_str(atype)):
                obj_like_nodes.append(an)
        suppress_main_name = _attr(obj_like_nodes[0], 'name') if (not any_main_attr and len(obj_like_nodes) == 1) else None
        for a in all_attr_nodes:
            ao = OrderedDict()
            ao['name'] = _attr(a, 'name')
            ty = decompile_type(a.find('lf:Type', NS))
            if ty:
                ao['type'] = ty
            # valueType: <Settings xsi:type="v8:TypeDescription">; Planner/Chart — отдельно.
            set_node = a.find('lf:Settings', NS)
            if set_node is not None and re.search(r'TypeDescription$', _attr(set_node, 'type', NS_XSI)):
                vt = decompile_type(set_node)
                ao['valueType'] = vt if vt else ''
            elif set_node is not None and re.search(r'Planner$', _attr(set_node, 'type', NS_XSI)):
                ao['planner'] = build_planner_settings(set_node)
            elif set_node is not None and re.search(r'd4p1:(Gantt)?Chart$', _attr(set_node, 'type', NS_XSI)):
                ao['chart'] = build_chart_settings(set_node)
            if get_child(a, 'MainAttribute') == 'true':
                ao['main'] = True
            elif suppress_main_name and ao['name'] == suppress_main_name:
                ao['main'] = False
            vw = decompile_xr_flag(a, 'View')
            if vw is not None:
                ao['view'] = vw
            ed = decompile_xr_flag(a, 'Edit')
            if ed is not None:
                ao['edit'] = ed
            is_main = (ao.get('main') is True)
            t_node = a.find('lf:Title', NS)
            if t_node is not None:
                t = get_lang_text_ws(t_node)
                if t is not None:
                    if is_main or not isinstance(t, str) or not _ps_ieq(t, title_from_name(ao['name'])):
                        ao['title'] = t
            elif not is_main:
                ao['title'] = ''
            if get_child(a, 'SavedData') == 'true':
                ao['savedData'] = True
            elif ao.get('main') is True and re.search(r'^(CatalogObject|DocumentObject|ChartOfAccountsObject|ChartOfCalculationTypesObject|ChartOfCharacteristicTypesObject|ExchangePlanObject|BusinessProcessObject|TaskObject)\.|RecordManager\.', _ps_str(ao.get('type'))):
                ao['savedData'] = False
            save_node = a.find('lf:Save', NS)
            if save_node is not None:
                nm = _ps_str(ao['name'])
                flds = [_text(f) for f in save_node.findall('lf:Field', NS)]
                if len(flds) == 1 and flds[0] == nm:
                    ao['save'] = True
                elif len(flds) > 0:
                    stripped = []
                    for f in flds:
                        m = re.match('^' + re.escape(nm) + r'\.([^.]+)$', f)
                        if m and not re.match(r'^\d+/\d+', m.group(1)):
                            stripped.append(m.group(1))
                        else:
                            stripped.append(f)
                    ao['save'] = stripped[0] if len(stripped) == 1 else stripped
            fc = get_child(a, 'FillCheck')
            if fc:
                ao['fillCheck'] = fc
            afo = decompile_functional_options(a)
            if _ps_truthy(afo):
                ao['functionalOptions'] = afo
            cols_node = a.find('lf:Columns', NS)
            if cols_node is not None:
                cols = []
                for c in cols_node.findall('lf:Column', NS):
                    cols.append(decompile_attr_column(c))
                if len(cols) > 0:
                    ao['columns'] = cols
                add_nodes = cols_node.findall('lf:AdditionalColumns', NS)
                if len(add_nodes) > 0:
                    add_list = []
                    for an2 in add_nodes:
                        ac_obj = OrderedDict()
                        ac_obj['table'] = _attr(an2, 'table')
                        ac_cols = []
                        for c in an2.findall('lf:Column', NS):
                            ac_cols.append(decompile_attr_column(c))
                        ac_obj['columns'] = ac_cols
                        add_list.append(ac_obj)
                    ao['additionalColumns'] = add_list
            # UseAlways: префикс "ИмяРеквизита." снимаем; маркер "~" сохраняем (префикс после него).
            ua_node = a.find('lf:UseAlways', NS)
            if ua_node is not None:
                prefix = _ps_str(ao['name']) + '.'
                shorts = []
                for fn in ua_node.findall('lf:Field', NS):
                    t = (_text(fn) or '').strip()
                    if t.startswith('~'):
                        rest = t[1:]
                        if rest.startswith(prefix):
                            rest = rest[len(prefix):]
                        t = '~' + rest
                    elif t.startswith(prefix):
                        t = t[len(prefix):]
                    shorts.append(t)
                if 'columns' in ao:
                    rest_list = []
                    for s in shorts:
                        col = None
                        for cc in ao['columns']:
                            if cc.get('name') == s:
                                col = cc
                                break
                        if col is not None:
                            col['useAlways'] = True
                        else:
                            rest_list.append(s)
                    if len(rest_list) > 0:
                        ao['useAlways'] = rest_list
                elif len(shorts) > 0:
                    ao['useAlways'] = shorts
            # Settings динамического списка (xsi:type=DynamicList)
            set_node = a.find('lf:Settings', NS)
            if set_node is not None and re.search(r'DynamicList$', _attr(set_node, 'type', NS_XSI)):
                so = OrderedDict()
                afaf = get_child(set_node, 'AutoFillAvailableFields')
                if afaf is not None:
                    so['autoFillAvailableFields'] = (afaf == 'true')
                mt = get_child(set_node, 'MainTable')
                if mt:
                    so['mainTable'] = mt
                gifp = get_child(set_node, 'GetInvisibleFieldPresentations')
                if gifp is not None:
                    so['getInvisibleFieldPresentations'] = (gifp == 'true')
                kt = get_child(set_node, 'KeyType')
                if kt:
                    so['keyType'] = kt
                kf_nodes = [_text(x) for x in set_node.findall('lf:KeyField', NS)]
                if len(kf_nodes) > 0:
                    so['keyFields'] = kf_nodes
                asus = get_child(set_node, 'AutoSaveUserSettings')
                if asus is not None:
                    so['autoSaveUserSettings'] = (asus == 'true')
                qt_node = set_node.find('lf:QueryText', NS)
                has_q = bool(qt_node is not None and _text(qt_node))
                if has_q:
                    so['query'] = maybe_externalize_query(_text(qt_node), _ps_str(ao['name']))
                mq_v = get_child(set_node, 'ManualQuery')
                if mq_v is not None:
                    mq_actual = (mq_v == 'true')
                    if mq_actual != has_q:
                        so['manualQuery'] = mq_actual
                if get_child(set_node, 'DynamicDataRead') == 'false':
                    so['dynamicDataRead'] = False
                field_nodes = set_node.findall('lf:Field', NS)
                if len(field_nodes) > 0:
                    fields = []
                    for fn in field_nodes:
                        fo = OrderedDict()
                        fld = get_child(fn, 'field')
                        dp = get_child(fn, 'dataPath')
                        if fld:
                            fo['field'] = fld
                        if has_child(fn, 'dataPath') and dp != fld:
                            fo['dataPath'] = dp
                        f_type_attr = _attr(fn, 'type', NS_XSI)
                        if re.search(r'NestedDataSet$', f_type_attr):
                            fo['nested'] = True
                        elif re.search(r'Folder$', f_type_attr):
                            fo['folder'] = True
                        ftn = fn.find('dcssch:title', NS)
                        if ftn is not None:
                            t = get_lang_text(ftn)
                            if t is not None:
                                fo['title'] = t
                        fvt = fn.find('dcssch:valueType', NS)
                        if fvt is not None:
                            fvt_val = decompile_type(fvt)
                            if fvt_val:
                                fo['valueType'] = fvt_val
                        fpe = get_child(fn, 'presentationExpression')
                        if fpe is not None and fpe != '':
                            fo['presentationExpression'] = fpe
                        fapp_node = fn.find('dcssch:appearance', NS)
                        if fapp_node is not None:
                            fap = get_settings_appearance(fapp_node)
                            if fap and len(fap) > 0:
                                fo['appearance'] = fap
                        fur_node = fn.find('dcssch:useRestriction', NS)
                        if fur_node is not None:
                            fur = build_restrict_obj(fur_node)
                            if len(fur) > 0:
                                fo['useRestriction'] = fur
                        faur_node = fn.find('dcssch:attributeUseRestriction', NS)
                        if faur_node is not None:
                            faur = build_restrict_obj(faur_node)
                            if len(faur) > 0:
                                fo['attributeUseRestriction'] = faur
                        fip_node = fn.find('dcssch:inputParameters', NS)
                        if fip_node is not None:
                            fip = build_dl_input_parameters(fip_node)
                            if len(fip) > 0:
                                fo['inputParameters'] = fip[0] if len(fip) == 1 else fip   # PS unwrap
                        fields.append(fo)
                    so['fields'] = fields
                calc_nodes = set_node.findall('lf:CalculatedField', NS)
                if len(calc_nodes) > 0:
                    cfs = []
                    for cn in calc_nodes:
                        cfs.append(build_calc_field(cn))
                    so['calculatedFields'] = cfs
                param_nodes = set_node.findall('lf:Parameter', NS)
                if len(param_nodes) > 0:
                    dl_pars = []
                    for pn in param_nodes:
                        dl_pars.append(build_dl_parameter(pn))
                    so['parameters'] = dl_pars
                ls_node = set_node.find('lf:ListSettings', NS)
                if ls_node is not None:
                    f_node = ls_node.find('dcsset:filter', NS)
                    if f_node is not None and f_node.find('dcsset:item', NS) is not None:
                        flt = []
                        for fc in f_node.findall('dcsset:item', NS):
                            bi = build_filter_item(fc, 'settings/filter')
                            if bi is not None:
                                flt.append(bi)
                        if len(flt) > 0:
                            so['filter'] = flt
                    o_node = ls_node.find('dcsset:order', NS)
                    if o_node is not None and o_node.find('dcsset:item', NS) is not None:
                        ordr = build_order(o_node, 'settings/order')
                        if len(ordr) > 0:
                            so['order'] = ordr
                    ca_node = ls_node.find('dcsset:conditionalAppearance', NS)
                    if ca_node is not None and ca_node.find('dcsset:item', NS) is not None:
                        ca = build_conditional_appearance(ca_node, 'settings/conditionalAppearance')
                        if len(ca) > 0:
                            so['conditionalAppearance'] = ca
                    dp_node = ls_node.find('dcsset:dataParameters', NS)
                    if dp_node is not None and dp_node.find('dcscor:item', NS) is not None:
                        dp = build_form_data_parameters(dp_node)
                        if len(dp) > 0:
                            so['dataParameters'] = dp
                    grp_item_node = ls_node.find('dcsset:item', NS)
                    grouping = None
                    if grp_item_node is not None:
                        grouping = build_list_grouping(grp_item_node)
                    if grouping is not None:
                        so['grouping'] = grouping
                    ls_shape = get_list_settings_shape(ls_node, grouping is not None)
                    if ls_shape is not None:
                        so['listSettings'] = ls_shape
                if len(so) > 0:
                    ao['settings'] = so
            attrs.append(ao)
        if len(attrs) > 0:
            dsl['attributes'] = attrs

    # conditionalAppearance формы (<ConditionalAppearance> — последний child <Attributes>)
    if attrs_node is not None:
        ca_node = attrs_node.find('lf:ConditionalAppearance', NS)
        if ca_node is not None:
            ca = build_conditional_appearance(ca_node, 'form/conditionalAppearance')
            if len(ca) > 0:
                dsl['conditionalAppearance'] = ca

    # parameters
    pars_node = root.find('lf:Parameters', NS)
    if pars_node is not None:
        pars = []
        for p in pars_node.findall('lf:Parameter', NS):
            po = OrderedDict()
            po['name'] = _attr(p, 'name')
            ty = decompile_type(p.find('lf:Type', NS))
            if ty:
                po['type'] = ty
            if get_child(p, 'KeyParameter') == 'true':
                po['key'] = True
            pars.append(po)
        if len(pars) > 0:
            dsl['parameters'] = pars

    # commands
    cmds_node = root.find('lf:Commands', NS)
    if cmds_node is not None:
        cmds = []
        for c in cmds_node.findall('lf:Command', NS):
            co = OrderedDict()
            co['name'] = _attr(c, 'name')
            act = get_child(c, 'Action')
            if act:
                co['action'] = act
            if get_child(c, 'ModifiesSavedData') == 'true':
                co['modifiesSavedData'] = True
            t_node = c.find('lf:Title', NS)
            if t_node is not None:
                t = get_lang_text(t_node)
                if t is not None:
                    co['title'] = t
            else:
                co['title'] = ''
            tt_node = c.find('lf:ToolTip', NS)
            if tt_node is not None:
                t = get_lang_text(tt_node)
                if t is not None:
                    co['tooltip'] = t
            us = decompile_xr_flag(c, 'Use')
            if us is not None:
                co['use'] = us
            cfo = decompile_functional_options(c)
            if _ps_truthy(cfo):
                co['functionalOptions'] = cfo
            cru = get_child(c, 'CurrentRowUse')
            if cru:
                co['currentRowUse'] = cru
            ate = get_child(c, 'AssociatedTableElementId')
            if ate:
                co['table'] = ate
            sc = get_child(c, 'Shortcut')
            if sc:
                co['shortcut'] = sc
            set_command_picture(co, c)
            rep = get_child(c, 'Representation')
            if rep:
                co['representation'] = rep
            cmds.append(co)
        if len(cmds) > 0:
            dsl['commands'] = cmds

    # commandInterface (форменный <CommandInterface>)
    ci = decompile_command_interface()
    if ci is not None:
        dsl['commandInterface'] = ci

    # --- 6. Output ---
    js = convert_to_compact_json(dsl)
    if output_path:
        with open(output_path, 'w', encoding='utf-8', newline='') as f:
            f.write(js)
        save_query_files()
        sys.stdout.write("form-decompile: %s\n" % output_path)
    else:
        sys.stdout.write(js + "\n")


def _local_name(tag):
    """{uri}local → local."""
    return tag.rsplit('}', 1)[-1] if '}' in tag else tag


if __name__ == '__main__':
    main()