#!/usr/bin/env python3
"""yida_page_compiler.py — 纯 Python 宜搭自定义页面编译管线。

两块能力按 region 分段维护：
  1) [region: page_compat]   现代 JSX (export default + useState/useEffect)
                             → 宜搭 runtime 兼容格式 (export function renderJsx
                             + _customState + didMount/didUnmount)
  2) [region: compiler]      page-compat → JSX→createElement → bind-this
                             → ESM→CJS → minify 的端到端编译。

公开 API（被 yida_custom_page_update.py 直接 import）：
  - compile_jsx(jsx_source, modern=None, minify=True) -> dict
  - compile_jsx_to_schema(jsx_source, form_uuid=None, ...) -> dict
  - build_page_source(source_code) -> dict
  - ensure_runtime_contract(source_code) -> dict
  - minify_js(source) -> str

外部依赖：无（纯 Python 标准库）。JSX 转换从 yida_jsx_pipeline.transform_jsx；
schema 外壳从 yida_page_schema.build_schema_content。
"""

import json
import re
import sys
from pathlib import Path

_SCRIPT_DIR = Path(__file__).resolve().parent
if str(_SCRIPT_DIR) not in sys.path:
    sys.path.insert(0, str(_SCRIPT_DIR))

# JSX 转换与 schema 外壳从其它聚合文件 import（避免重复实现）
from yida_jsx_pipeline import transform_jsx
from yida_page_schema import build_schema_content


# ===========================================================================
# region: page_compat —— modern JSX → 宜搭 runtime 格式
# ===========================================================================
#
# 支持的转换：
#   - export default function Page() → export function renderJsx()
#   - var [x, setX] = useState(init)  → this.getCustomState('x') / this.setCustomState({x: val})
#   - setX(function(prev) { ... })     → setCustomState calls updater with previous value
#   - useEffect(fn, [])               → didMount 生命周期
#   - useEffect cleanup return        → didUnmount 生命周期
#   - 移除 React/react-dom import
#   - const/let → var
#   - 补齐 runtime contract exports
# ---------------------------------------------------------------------------

_REMOVABLE_IMPORTS = frozenset(['react', 'react-dom', 'lodash', 'moment'])

_RUNTIME_EXPORTS = {
    'getCustomState': (
        'export function getCustomState(key) {\n'
        '  if (typeof _customState === "undefined") {\n'
        '    return key ? undefined : {};\n'
        '  }\n'
        '  if (key) {\n'
        '    return _customState[key];\n'
        '  }\n'
        '  return Object.assign({}, _customState);\n'
        '}'
    ),
    'setCustomState': (
        'export function setCustomState(newState) {\n'
        '  if (typeof _customState === "undefined") {\n'
        '    return;\n'
        '  }\n'
        '  Object.keys(newState || {}).forEach(function(key) {\n'
        '    var value = newState[key];\n'
        '    if (typeof value === "function") {\n'
        '      value = value(_customState[key]);\n'
        '    }\n'
        '    _customState[key] = value;\n'
        '  });\n'
        '  this.forceUpdate();\n'
        '}'
    ),
    'forceUpdate': (
        'export function forceUpdate() {\n'
        '  this.setState({ timestamp: new Date().getTime() });\n'
        '}'
    ),
    'didMount': 'export function didMount() {}',
    'didUnmount': 'export function didUnmount() {}',
}

_TIMESTAMP_NODE = (
    "React.createElement('div', {style: {display: 'none'}}, "
    "this.state && this.state.timestamp)"
)

_CUSTOM_STATE_DECL_RE = re.compile(r'\bvar\s+_customState\b')


def _build_render_jsx_with_marker(render_body):
    """把 render_body 包进 IIFE，外层加 timestamp marker。

    产出：
        export function renderJsx() {
          var __yidaTs = this.state && this.state.timestamp;
          var __yidaContent = (function() {
            ...原 render_body...
          }).call(this);
          return React.createElement('div', null,
            React.createElement('div', {style: {display: 'none'}}, __yidaTs),
            __yidaContent
          );
        }

    作用：__yidaTs 本体在 IIFE 之外被读取使 setState({timestamp}) 能被 React diff、
    隐藏 div 把 __yidaTs 放到 JSX 树里使其参与重渲染；原 content 不动。
    多一层匿名 <div> 包裹，不影响布局，仅 body > div > xxx 选择器会失效。
    """
    if not render_body:
        render_body = '  return null;'
    indented = '\n'.join(
        ('    ' + line) if line else line
        for line in render_body.split('\n')
    )
    return (
        'export function renderJsx() {\n'
        '  var __yidaTs = this.state && this.state.timestamp;\n'
        '  var __yidaContent = (function() {\n'
        + indented + '\n'
        '  }).call(this);\n'
        "  return React.createElement('div', null,\n"
        "    React.createElement('div', {style: {display: 'none'}}, __yidaTs),\n"
        '    __yidaContent\n'
        '  );\n'
        '}'
    )


def build_page_source(source_code):
    """将现代 JSX 页面源码转换为宜搭 runtime 兼容格式。

    Args:
        source_code: 现代格式的 JSX 源码（export default function Page）

    Returns:
        dict: {
            'code': str,       转换后的代码
            'lint': {'errors': [], 'warnings': []},
            'fixes': [str],    应用的修复描述
            'errors': [{'code': str, 'message': str}],
        }
    """
    if not _should_transform(source_code):
        result = ensure_runtime_contract(source_code)
        return {
            'code': result['code'],
            'lint': {'errors': [], 'warnings': []},
            'fixes': result['fixes'],
            'errors': [],
        }

    fixes = []
    errors = []

    # Step 0: 剥离 JSX 表达式注释 {/* ... */}
    source_code = _strip_jsx_comments(source_code, fixes)

    lines = source_code.split('\n')

    # Step 1: 移除 React 等 import
    lines = _remove_imports(lines, fixes, errors)

    # Step 2: const/let → var
    lines = _fix_variable_declarations(lines, fixes)

    # Step 3: 提取 Page 函数体
    page_info = _extract_page_function(lines, errors)
    if page_info is None:
        code = '\n'.join(lines)
        result = ensure_runtime_contract(code)
        return {
            'code': result['code'],
            'lint': {'errors': errors, 'warnings': []},
            'fixes': fixes + result['fixes'],
            'errors': errors,
        }

    # Step 4: 从函数体中提取 useState 和 useEffect
    body_lines = page_info['body_lines']
    state_info = _extract_use_state(body_lines, fixes, errors)
    effect_info = _extract_use_effect(body_lines, fixes, errors)

    # Step 5: 构建 renderJsx 函数
    remaining_body = _remove_hooks_from_body(body_lines, state_info, effect_info)

    # Step 5.5: 分离函数体为三类
    separated = _separate_body_parts(remaining_body, state_info)

    # Step 6: 构建输出
    output_parts = []
    output_parts.append('\n'.join(page_info['before_lines']))

    # _customState 初始化
    state_inits = []
    for st in state_info['states']:
        state_inits.append(f"  {st['name']}: {st['init']},")
    if state_inits:
        output_parts.append('var _customState = {\n' + '\n'.join(state_inits) + '\n};')
    else:
        output_parts.append('var _customState = {};')

    # 模块顶层变量
    if separated['top_level_vars']:
        top_vars = _replace_state_references(separated['top_level_vars'], state_info)
        output_parts.append(top_vars)

    # 纯工具函数
    for fn_code in separated['utility_functions']:
        output_parts.append(fn_code.strip())

    # 导出函数声明（变为组件方法）
    function_names = separated['function_names']
    for fn_code in separated['functions']:
        fn_transformed = _replace_state_references(fn_code, state_info)
        fn_transformed = _add_bind_this_to_then_catch(fn_transformed)
        fn_transformed = _replace_fn_calls_with_this(fn_transformed, function_names)
        output_parts.append('export ' + fn_transformed.strip())

    # renderJsx
    render_body = _replace_state_references(separated['render_body'], state_info, receiver='self')
    render_body = _replace_fn_calls_with_this(render_body, function_names)
    if ('self.getCustomState' in render_body or 'self.setCustomState' in render_body) \
            and not re.search(r'\bvar\s+self\s*=\s*this\b', render_body):
        render_body = 'var self = this;\n' + render_body
    render_fn = _build_render_jsx_with_marker(render_body)
    output_parts.append(render_fn)
    fixes.append('Converted export default function Page → export function renderJsx (with re-render marker)')

    # didMount/didUnmount
    mount_code = _replace_state_references(effect_info['mount_code'], state_info) if effect_info['mount_code'] else ''
    unmount_code = _replace_state_references(effect_info['unmount_code'], state_info) if effect_info['unmount_code'] else ''

    if mount_code:
        mount_code = _replace_fn_calls_with_this(mount_code, function_names)
        mount_code = _add_bind_this_to_then_catch(mount_code)
    if unmount_code:
        unmount_code = _replace_fn_calls_with_this(unmount_code, function_names)
        unmount_code = _add_bind_this_to_then_catch(unmount_code)

    if mount_code:
        mount_fn = 'export function didMount() {\n' + mount_code + '\n}'
        output_parts.append(mount_fn)
        fixes.append('Extracted useEffect(fn, []) → didMount')
    else:
        output_parts.append('export function didMount() {}')

    if unmount_code:
        unmount_fn = 'export function didUnmount() {\n' + unmount_code + '\n}'
        output_parts.append(unmount_fn)
        fixes.append('Extracted useEffect cleanup → didUnmount')
    else:
        output_parts.append('export function didUnmount() {}')

    if page_info['after_lines']:
        output_parts.append('\n'.join(page_info['after_lines']))

    code = '\n\n'.join(p for p in output_parts if p.strip())
    result = ensure_runtime_contract(code)

    return {
        'code': result['code'],
        'lint': {'errors': errors, 'warnings': []},
        'fixes': fixes + result['fixes'],
        'errors': errors,
    }


def ensure_runtime_contract(source_code):
    """确保代码包含宜搭 runtime 必需的 export 函数。

    Args:
        source_code: 已转换的源码

    Returns:
        dict: {'code': str, 'fixes': [str]}
    """
    fixes = []
    append_parts = []

    exported_names = set(re.findall(r'export\s+function\s+(\w+)', source_code))

    if '_customState' in source_code and not _CUSTOM_STATE_DECL_RE.search(source_code):
        append_parts.insert(0, 'var _customState = {};')
        fixes.append('Inserted missing _customState store')

    if 'getCustomState' not in exported_names or 'setCustomState' not in exported_names:
        if '_customState' not in source_code:
            append_parts.insert(0, 'var _customState = {};')
            fixes.append('Inserted default _customState store')

    for name, body in _RUNTIME_EXPORTS.items():
        if name not in exported_names:
            append_parts.append(body)
            fixes.append(f'Inserted missing export function {name}')

    if not append_parts:
        return {'code': source_code, 'fixes': fixes}

    return {
        'code': source_code.rstrip() + '\n\n' + '\n\n'.join(append_parts) + '\n',
        'fixes': fixes,
    }


def _should_transform(source_code):
    """判断是否需要做 modern → yida 转换"""
    if re.search(r'export\s+function\s+renderJsx\s*\(', source_code):
        return False
    return bool(re.search(r'export\s+default\b', source_code))


def _strip_jsx_comments(source_code, fixes):
    """剥离 JSX 表达式容器注释 {/* ... */}（避免 ,, 双逗号）。"""
    if not source_code or '/*' not in source_code:
        return source_code
    original = source_code
    source_code = re.sub(
        r'(?m)^[ \t]*\{\s*/\*[\s\S]*?\*/\s*\}[ \t]*\r?\n',
        '',
        source_code,
    )
    source_code = re.sub(
        r'(>)\s*\{\s*/\*[\s\S]*?\*/\s*\}\s*(<)',
        r'\1\2',
        source_code,
    )
    if source_code != original:
        fixes.append('Stripped JSX expression comments (avoid ",," double-comma)')
    return source_code


def _remove_imports(lines, fixes, errors):
    """移除已知的 removable imports，对未知的报错"""
    result = []
    for line in lines:
        match = re.match(r"^\s*import\s+.*?from\s+['\"]([^'\"]+)['\"]", line)
        if not match:
            match = re.match(r"^\s*import\s+['\"]([^'\"]+)['\"]", line)
        if match:
            module_name = match.group(1).lower()
            if module_name in _REMOVABLE_IMPORTS:
                fixes.append(f'Removed {module_name} import')
                continue
            else:
                errors.append({
                    'code': 'UNSUPPORTED_IMPORT',
                    'message': f'Unsupported import "{match.group(1)}". '
                               'Use this.utils.loadScript for external libraries.',
                })
        result.append(line)
    return result


def _fix_variable_declarations(lines, fixes):
    """const/let → var"""
    result = []
    pattern = re.compile(r'^(\s*)(const|let)\b(.*)$')
    changed = False
    for line in lines:
        m = pattern.match(line)
        if m:
            result.append(f'{m.group(1)}var{m.group(3)}')
            changed = True
        else:
            result.append(line)
    if changed:
        fixes.append('Replaced const/let with var')
    return result


def _extract_page_function(lines, errors):
    """提取 export default function Page() { ... } 的位置和内容"""
    pattern = re.compile(r'^(\s*)export\s+default\s+function\s+\w*\s*\([^)]*\)\s*\{?\s*$')
    start_idx = None

    for i, line in enumerate(lines):
        if pattern.match(line):
            start_idx = i
            break
        if re.match(r'^\s*export\s+default\s+function\b', line):
            start_idx = i
            break

    if start_idx is None:
        errors.append({
            'code': 'NO_DEFAULT_EXPORT',
            'message': 'Cannot find export default function Page().',
        })
        return None

    brace_start = None
    text_from_start = '\n'.join(lines[start_idx:])
    for i, ch in enumerate(text_from_start):
        if ch == '{':
            brace_start = i
            break

    if brace_start is None:
        errors.append({'code': 'PARSE_ERROR', 'message': 'Cannot find opening brace of Page function.'})
        return None

    depth = 0
    all_text = '\n'.join(lines)
    char_pos = len('\n'.join(lines[:start_idx])) + (1 if start_idx > 0 else 0) + brace_start

    end_char = None
    pos = char_pos
    while pos < len(all_text):
        ch = all_text[pos]
        if ch in ('"', "'", '`'):
            pos = _skip_string_in_source(all_text, pos) + 1
            continue
        if ch == '{':
            depth += 1
        elif ch == '}':
            depth -= 1
            if depth == 0:
                end_char = pos
                break
        pos += 1

    if end_char is None:
        errors.append({'code': 'PARSE_ERROR', 'message': 'Cannot find closing brace of Page function.'})
        return None

    body_content = all_text[char_pos + 1:end_char]
    end_line = all_text[:end_char + 1].count('\n')

    before_lines = lines[:start_idx]
    after_lines = lines[end_line + 1:] if end_line + 1 < len(lines) else []
    body_lines = body_content.split('\n')

    return {
        'before_lines': before_lines,
        'body_lines': body_lines,
        'after_lines': after_lines,
    }


def _skip_string_in_source(text, pos):
    """跳过字符串字面量"""
    quote = text[pos]
    pos += 1
    while pos < len(text):
        ch = text[pos]
        if ch == '\\':
            pos += 2
            continue
        if ch == quote:
            return pos
        pos += 1
    return pos


def _extract_use_state(body_lines, fixes, errors):
    """提取所有 useState 声明（支持跨行初值）"""
    states = []
    body_text = '\n'.join(body_lines)
    decl_pattern = re.compile(
        r'(?m)^([ \t]*)var\s+\[(\w+)\s*,\s*(\w+)\]\s*=\s*useState\s*\('
    )
    for m in decl_pattern.finditer(body_text):
        name = m.group(2)
        setter = m.group(3)
        paren_start = m.end() - 1
        depth = 0
        pos = paren_start
        while pos < len(body_text):
            ch = body_text[pos]
            if ch in ('"', "'", '`'):
                pos = _skip_string_in_source(body_text, pos) + 1
                continue
            if ch == '(':
                depth += 1
            elif ch == ')':
                depth -= 1
                if depth == 0:
                    break
            pos += 1
        if depth != 0:
            errors.append({
                'code': 'UNSUPPORTED_USE_STATE',
                'message': f'Unbalanced parentheses in useState({name}) declaration.',
            })
            continue
        init_text = body_text[paren_start + 1:pos].strip()
        decl_end = pos + 1
        while decl_end < len(body_text) and body_text[decl_end] in ' \t':
            decl_end += 1
        if decl_end < len(body_text) and body_text[decl_end] == ';':
            decl_end += 1
        states.append({
            'name': name,
            'setter': setter,
            'init': init_text,
            'raw_text': body_text[m.start():decl_end],
        })

    for line in body_lines:
        hook_match = re.search(r'\buse([A-Z]\w*)\b', line)
        if hook_match:
            hook_name = 'use' + hook_match.group(1)
            if hook_name not in ('useState', 'useEffect'):
                errors.append({
                    'code': 'UNSUPPORTED_HOOK',
                    'message': f'{hook_name} is not supported.',
                })

    return {'states': states}


def _extract_use_effect(body_lines, fixes, errors):
    """提取 useEffect(fn, []) 调用"""
    mount_code = ''
    unmount_code = ''

    body_text = '\n'.join(body_lines)
    effect_pattern = re.compile(r'useEffect\s*\(\s*function\s*\(\)\s*\{')

    for match in effect_pattern.finditer(body_text):
        start = match.end()
        depth = 1
        pos = start
        while pos < len(body_text) and depth > 0:
            ch = body_text[pos]
            if ch in ('"', "'", '`'):
                pos = _skip_string_in_source(body_text, pos) + 1
                continue
            if ch == '{':
                depth += 1
            elif ch == '}':
                depth -= 1
            pos += 1

        fn_body = body_text[start:pos - 1]

        remaining_after_fn = body_text[pos:].lstrip()
        if not remaining_after_fn.startswith(','):
            errors.append({'code': 'UNSUPPORTED_EFFECT_DEPS', 'message': 'useEffect must have [], as second arg.'})
            continue
        deps_start = body_text.index(',', pos) + 1
        deps_text = body_text[deps_start:].lstrip()
        if not deps_text.startswith('[]') and not deps_text.startswith('[ ]'):
            errors.append({'code': 'UNSUPPORTED_EFFECT_DEPS', 'message': 'Only useEffect(fn, []) is supported.'})
            continue

        mount_lines, unmount_lines = _split_effect_body(fn_body)
        if mount_lines:
            mount_code += mount_lines + '\n'
        if unmount_lines:
            unmount_code += unmount_lines + '\n'

    return {
        'mount_code': mount_code.strip(),
        'unmount_code': unmount_code.strip(),
    }


def _split_effect_body(fn_body):
    """将 effect 函数体分为 mount 代码和 unmount（return 的 cleanup 函数）"""
    lines = fn_body.strip().split('\n')
    mount_lines = []
    unmount_lines = []

    return_idx = None
    for i in range(len(lines) - 1, -1, -1):
        if re.match(r'^\s*return\s+function\b', lines[i]):
            return_idx = i
            break
        if re.match(r'^\s*return\s*\(\s*function\b', lines[i]):
            return_idx = i
            break

    if return_idx is None:
        return '\n'.join(lines), ''

    mount_lines = lines[:return_idx]

    return_text = '\n'.join(lines[return_idx:])
    brace_match = return_text.find('{')
    if brace_match == -1:
        return '\n'.join(mount_lines), ''

    depth = 0
    end_pos = None
    for i in range(brace_match, len(return_text)):
        if return_text[i] == '{':
            depth += 1
        elif return_text[i] == '}':
            depth -= 1
            if depth == 0:
                end_pos = i
                break

    if end_pos is not None:
        cleanup_body = return_text[brace_match + 1:end_pos]
        unmount_lines = cleanup_body.strip()

    return '\n'.join(mount_lines), unmount_lines


def _remove_hooks_from_body(body_lines, state_info, effect_info):
    """从函数体中移除 useState 和 useEffect 声明行"""
    body_text = '\n'.join(body_lines)

    for st in state_info['states']:
        raw = st.get('raw_text') or st.get('line') or ''
        if raw:
            body_text = body_text.replace(raw, '')

    effect_pattern = re.compile(r'\s*useEffect\s*\(')
    while True:
        m = effect_pattern.search(body_text)
        if not m:
            break
        start = m.start()
        paren_start = body_text.index('(', m.start())
        depth = 0
        pos = paren_start
        while pos < len(body_text):
            ch = body_text[pos]
            if ch in ('"', "'", '`'):
                pos = _skip_string_in_source(body_text, pos) + 1
                continue
            if ch == '(':
                depth += 1
            elif ch == ')':
                depth -= 1
                if depth == 0:
                    break
            pos += 1
        end = pos + 1
        if end < len(body_text) and body_text[end] == ';':
            end += 1
        body_text = body_text[:start] + body_text[end:]

    body_text = re.sub(r'\n{3,}', '\n\n', body_text)
    return body_text.strip()


def _replace_state_references(body_text, state_info, receiver='this'):
    """将 state 变量引用替换为 this.getCustomState/setCustomState（跳过字符串）。"""
    for st in state_info['states']:
        name = st['name']
        setter = st['setter']
        body_text = _replace_setter_calls(body_text, setter, name, receiver=receiver)
        body_text = _replace_state_reads(body_text, name, receiver=receiver)
    return body_text


def _replace_state_reads(text, state_name, receiver='this'):
    """替换裸变量名引用为 this.getCustomState('name')，跳过字符串内容和对象属性 key。"""
    pattern = re.compile(r'(?<![.\w])' + re.escape(state_name) + r'(?!\w)')
    result = []
    pos = 0
    while pos < len(text):
        ch = text[pos]
        if ch in ('"', "'", '`'):
            end = _find_string_end(text, pos)
            result.append(text[pos:end + 1])
            pos = end + 1
            continue
        m = pattern.match(text, pos)
        if m:
            after_end = m.end()
            preceding = ''.join(result).rstrip()

            if preceding and preceding[-1] == '>':
                prev_prev = preceding[-2] if len(preceding) >= 2 else ''
                if prev_prev not in ('=', '!', '<', '>'):
                    result.append(text[pos:m.end()])
                    pos = m.end()
                    continue

            rest_after = text[after_end:].lstrip()
            if rest_after and rest_after[0] == ':' and not rest_after.startswith('::'):
                if preceding and preceding[-1] in ('{', ',', '\n'):
                    result.append(text[pos:m.end()])
                    pos = m.end()
                    continue
            result.append(f"{receiver}.getCustomState('{state_name}')")
            pos = m.end()
        else:
            result.append(ch)
            pos += 1
    return ''.join(result)


def _replace_setter_calls(text, setter_name, state_name, receiver='this'):
    """替换 setX(value) 为 this.setCustomState({'x': value})，跳过字符串内容。"""
    setter_pattern = re.compile(r'(?<![.\w])' + re.escape(setter_name) + r'\s*\(')
    result_parts = []
    search_start = 0

    while search_start < len(text):
        ch = text[search_start] if search_start < len(text) else ''
        if ch in ('"', "'", '`'):
            end = _find_string_end(text, search_start)
            result_parts.append(text[search_start:end + 1])
            search_start = end + 1
            continue

        m = setter_pattern.search(text, search_start)
        if not m:
            result_parts.append(text[search_start:])
            break

        result_parts.append(text[search_start:m.start()])

        paren_start = m.end() - 1
        depth = 0
        pos = paren_start
        while pos < len(text):
            c = text[pos]
            if c in ('"', "'", '`'):
                pos = _find_string_end(text, pos) + 1
                continue
            if c == '(':
                depth += 1
            elif c == ')':
                depth -= 1
                if depth == 0:
                    break
            pos += 1
        arg_content = text[paren_start + 1:pos]
        replacement = f"{receiver}.setCustomState({{ '{state_name}': {arg_content} }})"
        result_parts.append(replacement)
        search_start = pos + 1

    return ''.join(result_parts)


def _find_string_end(text, start):
    """找到从 start 位置开始的字符串字面量结束位置（含闭合引号）"""
    quote = text[start]
    pos = start + 1
    if quote == '`':
        while pos < len(text):
            ch = text[pos]
            if ch == '\\':
                pos += 2
                continue
            if ch == '`':
                return pos
            if ch == '$' and pos + 1 < len(text) and text[pos + 1] == '{':
                pos += 2
                depth = 1
                while pos < len(text) and depth > 0:
                    if text[pos] == '{':
                        depth += 1
                    elif text[pos] == '}':
                        depth -= 1
                    pos += 1
                continue
            pos += 1
        return len(text) - 1
    while pos < len(text):
        ch = text[pos]
        if ch == '\\':
            pos += 2
            continue
        if ch == quote:
            return pos
        pos += 1
    return len(text) - 1



def _consume_var_declaration(lines, start_index):
    """从 lines[start_index] 起读一条完整的 var 声明，允许初值跨多行。

    跟踪 {} [] () 括号深度（跳过字符串、模板字符串、单/多行注释），
    括号深度归零的那一行视为声明结束。返回 (end_index_inclusive, full_text)。
    """
    depth = 0
    in_string = False
    string_quote = ''
    n = len(lines)
    end = start_index
    i = start_index
    while i < n:
        line = lines[i]
        j = 0
        L = len(line)
        while j < L:
            ch = line[j]
            if in_string:
                if string_quote == '`':
                    if ch == '\\' and j + 1 < L:
                        j += 2
                        continue
                    if ch == '`':
                        in_string = False
                    j += 1
                    continue
                if ch == '\\' and j + 1 < L:
                    j += 2
                    continue
                if ch == string_quote:
                    in_string = False
                j += 1
                continue
            if ch == '/' and j + 1 < L and line[j + 1] == '/':
                break
            if ch == '/' and j + 1 < L and line[j + 1] == '*':
                end_block = line.find('*/', j + 2)
                if end_block == -1:
                    j = L
                    break
                j = end_block + 2
                continue
            if ch in ('"', "'", '`'):
                in_string = True
                string_quote = ch
                j += 1
                continue
            if ch in '{[(':
                depth += 1
            elif ch in '}])':
                depth -= 1
            j += 1
        if depth <= 0:
            end = i
            break
        i += 1
    else:
        end = n - 1
    return end, '\n'.join(lines[start_index:end + 1])


def _var_function_to_declaration(decl_text):
    """Convert `var name = function(args) { ... };` to `function name(args) { ... }`."""
    header = re.match(r'^\s*var\s+(\w+)\s*=\s*function\s*(\([^)]*\))\s*\{', decl_text, re.S)
    if not header:
        return None, None
    name = header.group(1)
    args = header.group(2)
    open_brace = decl_text.find('{', header.start())
    close_brace = decl_text.rfind('}')
    if open_brace < 0 or close_brace <= open_brace:
        return None, None
    body = decl_text[open_brace + 1:close_brace]
    return name, f"function {name}{args} {{{body}\n}}"


def _extract_declared_var_names(decl_text):
    """Return declared identifiers from a `var ...` declaration.

    The modern authoring splitter needs these names to keep chained render
    derivations together, e.g. `filtered` followed by `amount =
    filtered.reduce(...)`. This parser only handles normal identifiers because
    useState destructuring is removed before this phase.
    """
    m = re.match(r'^\s*var\s+([\s\S]*)$', decl_text.strip())
    if not m:
        return []
    tail = m.group(1)
    names = []
    pos = 0
    n = len(tail)
    while pos < n:
        while pos < n and tail[pos].isspace():
            pos += 1
        ident = re.match(r'[A-Za-z_$][\w$]*', tail[pos:])
        if ident:
            names.append(ident.group(0))
            pos += len(ident.group(0))
        depth = 0
        while pos < n:
            ch = tail[pos]
            if ch in ('"', "'", '`'):
                pos = _find_string_end(tail, pos) + 1
                continue
            if ch in '([{':
                depth += 1
            elif ch in ')]}':
                depth -= 1
            elif ch == ',' and depth == 0:
                pos += 1
                break
            pos += 1
        else:
            break
    return names


def _references_any_identifier(text, names):
    """Whether text references any identifier in names outside strings."""
    if not names:
        return False
    clean_parts = []
    pos = 0
    while pos < len(text):
        ch = text[pos]
        if ch in ('"', "'", '`'):
            end = _find_string_end(text, pos)
            clean_parts.append(' ')
            pos = end + 1
        else:
            clean_parts.append(ch)
            pos += 1
    clean = ''.join(clean_parts)
    return any(re.search(r'\b' + re.escape(name) + r'\b', clean) for name in names)


def _separate_body_parts(body_text, state_info):
    """将函数体分离为：需导出的方法、模块级工具函数、顶层常量、render 部分。

    分类规则：
    - 函数内含 setState/getState 调用 → 导出为组件方法（用 this.xxx() 调用）
    - 纯工具函数（不依赖 state）→ 模块级普通函数（直接调用）
    - var 声明依赖 state → 放入 renderJsx
    - var 声明不依赖 state → 模块顶层常量
    - return 语句及之后 → render_body
    """
    lines = body_text.split('\n')
    exported_functions = []
    exported_fn_names = []
    utility_functions = []
    utility_fn_names = []
    top_level_vars = []
    render_lines = []
    render_var_names = set()

    state_setters = set(st['setter'] for st in state_info['states'])
    state_names = set(st['name'] for st in state_info['states'])

    i = 0
    found_return = False
    while i < len(lines):
        line = lines[i]
        stripped = line.strip()

        if found_return:
            render_lines.append(line)
            i += 1
            continue

        if re.match(r'^\s*return\s*[\(]', stripped) or stripped == 'return (' or stripped == 'return(':
            found_return = True
            render_lines.append(line)
            i += 1
            continue

        fn_match = re.match(r'^(\s*)function\s+(\w+)\s*\(', line)
        if fn_match:
            fn_name = fn_match.group(2)
            fn_start = i
            brace_depth = 0
            fn_end = i
            for j in range(i, len(lines)):
                for ch in lines[j]:
                    if ch == '{':
                        brace_depth += 1
                    elif ch == '}':
                        brace_depth -= 1
                if brace_depth == 0 and j > i:
                    fn_end = j
                    break
                if brace_depth == 0 and '{' in lines[j]:
                    fn_end = j
                    break
            fn_code = '\n'.join(lines[fn_start:fn_end + 1])

            uses_state = (
                any(s + '(' in fn_code for s in state_setters)
                or any(re.search(r'\b' + re.escape(sn) + r'\b', fn_code) for sn in state_names)
                or bool(re.search(r'\bthis\.', fn_code))
            )
            if uses_state:
                exported_functions.append(fn_code)
                exported_fn_names.append(fn_name)
            else:
                utility_functions.append(fn_code)
                utility_fn_names.append(fn_name)
            i = fn_end + 1
            continue

        if re.match(r'^\s*var\s+\w+\s*=\s*function\s*\(', line):
            decl_end, decl_text = _consume_var_declaration(lines, i)
            fn_name, fn_code = _var_function_to_declaration(decl_text)
            if fn_name and fn_code:
                exported_functions.append(fn_code)
                exported_fn_names.append(fn_name)
            else:
                render_lines.extend(lines[i:decl_end + 1])
            i = decl_end + 1
            continue

        if stripped.startswith('var ') and not stripped.startswith('var ['):
            decl_end, decl_text = _consume_var_declaration(lines, i)
            decl_names = _extract_declared_var_names(decl_text)
            uses_state_var = _references_any_identifier(decl_text, state_names)
            uses_render_var = _references_any_identifier(decl_text, render_var_names)
            if uses_state_var or uses_render_var:
                render_lines.extend(lines[i:decl_end + 1])
                render_var_names.update(decl_names)
            else:
                top_level_vars.extend(lines[i:decl_end + 1])
            i = decl_end + 1
            continue

        if stripped:
            render_lines.append(line)
        i += 1

    return {
        'functions': exported_functions,
        'function_names': exported_fn_names,
        'utility_functions': utility_functions,
        'utility_fn_names': utility_fn_names,
        'top_level_vars': '\n'.join(top_level_vars),
        'render_body': '\n'.join(render_lines).strip(),
    }


def _replace_fn_calls_with_this(code, function_names):
    """将裸函数调用 xxx() 替换为 this.xxx()（仅对导出为组件方法的函数）。"""
    for fn_name in function_names:
        pattern = re.compile(r'(?<!function )(?<![.\w])' + re.escape(fn_name) + r'(?=\s*\()')
        code = pattern.sub('this.' + fn_name, code)
    return code


def _add_bind_this_to_then_catch(code):
    """在 .then(function(...) { ... }) 和 .catch(function(...) { ... }) 回调中，
    如果内部使用了 this.，则在闭合 } 后添加 .bind(this)。
    """
    result = []
    pos = 0
    text = code

    while pos < len(text):
        match = None
        for method in ('then', 'catch'):
            pattern = '.' + method + '(function'
            if text[pos:pos + len(pattern)] == pattern:
                match = method
                break

        if match is None:
            result.append(text[pos])
            pos += 1
            continue

        method_text = '.' + match + '('
        result.append(method_text)
        pos += len(method_text)

        brace_pos = text.find('{', pos)
        if brace_pos == -1:
            result.append(text[pos:])
            break

        result.append(text[pos:brace_pos + 1])
        pos = brace_pos + 1

        depth = 1
        body_start = pos
        while pos < len(text) and depth > 0:
            ch = text[pos]
            if ch in ('"', "'", '`'):
                pos = _find_string_end(text, pos) + 1
                continue
            if ch == '{':
                depth += 1
            elif ch == '}':
                depth -= 1
            pos += 1

        fn_body = text[body_start:pos - 1]
        result.append(fn_body)

        if 'this.' in fn_body:
            result.append('}.bind(this)')
        else:
            result.append('}')

    return ''.join(result)


# ===========================================================================
# region: compiler —— page-compat → JSX→createElement → bind-this → ESM→CJS → minify
# ===========================================================================

def compile_jsx(jsx_source, modern=None, minify=True):
    """编译 JSX 源码为宜搭 runtime 兼容的 JS。

    Args:
        jsx_source: JSX/JS 源码字符串
        modern: True 强制走 page-compat 转换；None 自动判断
        minify: 是否压缩（默认 True）

    Returns:
        dict: {
            'source_code': str,        原始输入
            'intermediate_code': str,   page-compat 改写后的中间产物
            'compiled_code': str,       JSX 转换 + minify 后的最终 JS
            'lint': {'errors': [], 'warnings': []},
            'ok': bool,
            'errors': [{'message': str, ...}],
        }
    """
    errors = []

    # Step 1: page-compat 转换
    compat_result = build_page_source(jsx_source)
    intermediate_code = compat_result['code']
    lint = compat_result.get('lint', {'errors': [], 'warnings': []})

    if compat_result.get('errors'):
        for err in compat_result['errors']:
            errors.append(err)

    if lint.get('errors'):
        return {
            'source_code': jsx_source,
            'intermediate_code': intermediate_code,
            'compiled_code': '',
            'lint': lint,
            'ok': False,
            'errors': errors + lint['errors'],
        }

    # Step 2: JSX → React.createElement
    try:
        transformed_code = transform_jsx(intermediate_code)
    except Exception as exc:
        errors.append({'code': 'JSX_TRANSFORM_ERROR', 'message': str(exc)})
        return {
            'source_code': jsx_source,
            'intermediate_code': intermediate_code,
            'compiled_code': '',
            'lint': lint,
            'ok': False,
            'errors': errors,
        }

    # Step 2.5: 给含 this. 的匿名函数加 .bind(this)
    transformed_code = _bind_this_to_anonymous_fns(transformed_code)

    # Step 2.6: ESM exports → CommonJS（宜搭 runtime 只认 CommonJS）
    transformed_code = _convert_esm_to_commonjs(transformed_code)

    # Step 3: minify
    if minify:
        compiled_code = minify_js(transformed_code)
    else:
        compiled_code = transformed_code

    ok = len(errors) == 0
    return {
        'source_code': jsx_source,
        'intermediate_code': intermediate_code,
        'compiled_code': compiled_code,
        'lint': lint,
        'ok': ok,
        'errors': errors,
    }


def compile_jsx_to_schema(jsx_source, form_uuid=None, existing_data_source=None,
                          modern=None, minify=True):
    """编译 JSX 源码，可选生成完整自定义页面 schema。"""
    result = compile_jsx(jsx_source, modern=modern, minify=minify)

    if form_uuid and result.get('ok'):
        result['schema'] = build_schema_content(
            result['source_code'],
            result['compiled_code'],
            form_uuid,
            existing_data_source=existing_data_source,
        )
    else:
        result['schema'] = None

    return result


def minify_js(source):
    """简单 JS minifier：移除注释、压缩连续空白、保留字符串内容。"""
    result = []
    pos = 0
    length = len(source)

    while pos < length:
        ch = source[pos]

        if ch in ('"', "'"):
            end = _consume_string(source, pos)
            result.append(source[pos:end + 1])
            pos = end + 1
            continue

        if ch == '`':
            end = _consume_template(source, pos)
            result.append(source[pos:end + 1])
            pos = end + 1
            continue

        if ch == '/' and pos + 1 < length and source[pos + 1] == '/':
            while pos < length and source[pos] != '\n':
                pos += 1
            continue

        if ch == '/' and pos + 1 < length and source[pos + 1] == '*':
            pos += 2
            while pos < length - 1:
                if source[pos] == '*' and source[pos + 1] == '/':
                    pos += 2
                    break
                pos += 1
            else:
                pos = length
            continue

        if ch in (' ', '\t', '\r'):
            while pos < length and source[pos] in (' ', '\t', '\r'):
                pos += 1
            if result and result[-1] and result[-1][-1:].isalnum() or (result and result[-1][-1:] == '_'):
                if pos < length and (source[pos].isalnum() or source[pos] == '_'):
                    result.append(' ')
            continue

        if ch == '\n':
            while pos < length and source[pos] in ('\n', '\r', ' ', '\t'):
                pos += 1
            if result and result[-1] and result[-1][-1:] not in ('{', '}', ';', ',', '(', '[', '\n', ''):
                result.append('\n')
            continue

        result.append(ch)
        pos += 1

    return ''.join(result)


def _consume_string(source, start):
    """找到字符串字面量的结束位置（含闭合引号）"""
    quote = source[start]
    pos = start + 1
    while pos < len(source):
        ch = source[pos]
        if ch == '\\':
            pos += 2
            continue
        if ch == quote:
            return pos
        pos += 1
    return len(source) - 1


def _consume_template(source, start):
    """找到模板字面量的结束位置（含闭合反引号）"""
    pos = start + 1
    while pos < len(source):
        ch = source[pos]
        if ch == '\\':
            pos += 2
            continue
        if ch == '`':
            return pos
        if ch == '$' and pos + 1 < len(source) and source[pos + 1] == '{':
            pos += 2
            depth = 1
            while pos < len(source) and depth > 0:
                if source[pos] == '{':
                    depth += 1
                elif source[pos] == '}':
                    depth -= 1
                elif source[pos] == '\\':
                    pos += 1
                pos += 1
            continue
        pos += 1
    return len(source) - 1


def _bind_this_to_anonymous_fns(code):
    """给含有 this. 引用的匿名函数表达式自动添加 .bind(this)。"""
    result = []
    pos = 0
    length = len(code)

    while pos < length:
        fn_idx = code.find('function', pos)
        if fn_idx == -1:
            result.append(code[pos:])
            break

        if fn_idx > 0 and (code[fn_idx - 1].isalnum() or code[fn_idx - 1] == '_'):
            result.append(code[pos:fn_idx + 8])
            pos = fn_idx + 8
            continue
        after_fn = fn_idx + 8
        if after_fn < length and (code[after_fn].isalnum() or code[after_fn] == '_'):
            pass

        result.append(code[pos:fn_idx])

        line_start = code.rfind('\n', 0, fn_idx)
        line_start = line_start + 1 if line_start != -1 else 0
        prefix = code[line_start:fn_idx].strip()
        is_declaration = (prefix == '' or prefix == 'export')

        scan = fn_idx + 8
        while scan < length and code[scan] in (' ', '\t'):
            scan += 1

        if scan < length and (code[scan].isalpha() or code[scan] == '_'):
            while scan < length and (code[scan].isalnum() or code[scan] == '_'):
                scan += 1
            while scan < length and code[scan] in (' ', '\t'):
                scan += 1

        if scan >= length or code[scan] != '(':
            result.append('function')
            pos = fn_idx + 8
            continue

        depth = 1
        scan += 1
        while scan < length and depth > 0:
            ch = code[scan]
            if ch == '(':
                depth += 1
            elif ch == ')':
                depth -= 1
            elif ch in ('"', "'", '`'):
                scan = _skip_str_for_bind(code, scan)
            scan += 1
        paren_end = scan

        while scan < length and code[scan] in (' ', '\t', '\n', '\r'):
            scan += 1

        if scan >= length or code[scan] != '{':
            result.append(code[fn_idx:paren_end])
            pos = paren_end
            continue

        brace_start = scan

        if is_declaration:
            result.append(code[fn_idx:brace_start + 1])
            pos = brace_start + 1
            continue

        depth = 1
        scan += 1
        while scan < length and depth > 0:
            ch = code[scan]
            if ch in ('"', "'", '`'):
                scan = _skip_str_for_bind(code, scan)
                scan += 1
                continue
            if ch == '{':
                depth += 1
            elif ch == '}':
                depth -= 1
            scan += 1
        brace_end = scan

        fn_body = code[brace_start + 1:brace_end - 1]
        result.append(code[fn_idx:brace_end])

        if 'this.' in fn_body:
            rest = code[brace_end:brace_end + 30]
            if not rest.lstrip(' \t').startswith('.bind(this)'):
                result.append('.bind(this)')

        pos = brace_end

    return ''.join(result)


def _skip_str_for_bind(code, pos):
    """跳过字符串/模板字面量，返回闭合引号的位置"""
    quote = code[pos]
    pos += 1
    while pos < len(code):
        ch = code[pos]
        if ch == '\\':
            pos += 2
            continue
        if quote == '`' and ch == '$' and pos + 1 < len(code) and code[pos + 1] == '{':
            pos += 2
            depth = 1
            while pos < len(code) and depth > 0:
                if code[pos] == '{':
                    depth += 1
                elif code[pos] == '}':
                    depth -= 1
                pos += 1
            continue
        if ch == quote:
            return pos
        pos += 1
    return pos - 1


def _convert_esm_to_commonjs(code):
    """将 export function xxx 转换为宜搭 runtime 能识别的格式。

    宜搭 runtime（render-engine）期望代码是一个包裹在 function 中的块，
    通过 Babel 编译后产出 CommonJS 风格：
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.renderJsx = renderJsx;
      exports.didMount = didMount;
      ...
      function renderJsx() { ... }

    但实际上宜搭更简单：它直接 eval 代码后从 exports 对象取函数。
    """
    lines = code.split('\n')
    result_lines = ['"use strict";', '']
    export_names = []

    for line in lines:
        m = re.match(r'^export\s+function\s+(\w+)', line)
        if m:
            fn_name = m.group(1)
            export_names.append(fn_name)
            result_lines.append(line.replace('export ', '', 1))
        else:
            result_lines.append(line)

    if export_names:
        result_lines.append('')
        for name in export_names:
            result_lines.append(f'exports.{name} = {name};')

    return '\n'.join(result_lines)