"""
系统总结节点

收集和展示AI创建的完整系统信息，包括应用、表单模块和仪表盘
"""
import ast
import json
import logging
from datetime import datetime
from typing import Any, Dict, List, Optional

from ..base import BaseNode, NodeContext, NodeResult
from ..registry import NodeRegistry

logger = logging.getLogger(__name__)


@NodeRegistry.register
class SystemSummaryNode(BaseNode):
    """
    系统总结节点

    收集和展示AI创建的完整系统信息，支持以下场景：
    1. 完整应用创建：应用 + 多个表单模块 + 仪表盘
    2. 子应用内创建模块：仅多个表单模块
    3. 单个表单创建：单个表单模块
    """

    node_type = 'system_summary'
    node_name = '系统总结'
    node_category = 'application'
    node_icon = 'clipboard-check'
    node_description = '收集和展示AI创建的完整系统信息'

    inputs = [
        {
            'name': 'app_info',
            'type': 'object',
            'description': '应用信息（来自AppCreate节点，可选）',
            'required': False,
        },
        {
            'name': 'form_results',
            'type': 'array',
            'description': '表单结果列表（来自循环节点或单个表单发布节点）',
            'required': True,
        },
        {
            'name': 'dashboard_info',
            'type': 'object',
            'description': '仪表盘信息（来自DashboardPublish节点，可选）',
            'required': False,
        },
        {
            'name': 'summary_title',
            'type': 'string',
            'description': '总结标题',
            'required': False,
        },
    ]

    outputs = [
        {
            'name': 'summary',
            'type': 'object',
            'description': '完整的总结数据',
        },
        {
            'name': 'total_forms',
            'type': 'number',
            'description': '表单总数',
        },
        {
            'name': 'has_app',
            'type': 'boolean',
            'description': '是否包含应用',
        },
        {
            'name': 'has_dashboard',
            'type': 'boolean',
            'description': '是否包含仪表盘',
        },
    ]

    def execute(self, context: NodeContext) -> NodeResult:
        """执行节点"""
        try:
            # 检查是否有用户确认（点击完成按钮）
            user_input = context.variables.get('__user_input__')
            if user_input:
                # 用户已确认，直接返回成功
                logger.info('SystemSummaryNode - 用户已确认，完成展示')
                context.variables.pop('__user_input__', None)

                # 从用户输入中获取之前构建的总结数据
                summary_data = self._parse_user_input(user_input)
                if summary_data:
                    return self._build_final_result(summary_data)

            # 获取输入参数
            app_info_raw = self.config.get('app_info', '')
            form_results_raw = self.config.get('form_results', '')
            dashboard_info_raw = self.config.get('dashboard_info', '')
            summary_title = context.resolve_template(self.config.get('summary_title', ''))
            show_statistics = self.config.get('show_statistics', True)
            base_url = context.resolve_template(self.config.get('base_url', ''))

            # 解析变量引用
            app_info = self._resolve_variable_value(context, app_info_raw)
            form_results = self._resolve_variable_value(context, form_results_raw)
            dashboard_info = self._resolve_variable_value(context, dashboard_info_raw)

            logger.info(f'SystemSummaryNode - 开始构建系统总结')
            logger.info(f'SystemSummaryNode - app_info: {bool(app_info)}, form_results: {type(form_results)}, dashboard_info: {bool(dashboard_info)}')

            # 处理表单结果
            forms = self._process_form_results(form_results)

            # 处理应用信息
            app = self._process_app_info(app_info) if app_info else None

            # 处理仪表盘信息
            dashboard = self._process_dashboard_info(dashboard_info) if dashboard_info else None

            # 构建总结数据
            summary = self._build_summary(
                title=summary_title or '系统创建完成',
                app=app,
                forms=forms,
                dashboard=dashboard,
                show_statistics=show_statistics,
                base_url=base_url,
            )

            logger.info(f'SystemSummaryNode - 总结构建完成: {len(forms)} 个表单')

            # 返回等待用户确认的结果
            return NodeResult(
                success=True,
                output=summary,
                output_variables={
                    'summary': summary,
                    'total_forms': len(forms),
                    'has_app': app is not None,
                    'has_dashboard': dashboard is not None,
                },
                waiting_for_input=True,
                waiting_config={
                    'type': 'design_preview',
                    'preview_type': 'system_summary',
                    'title': summary.get('title', '系统创建完成'),
                    'data': summary,
                    'editable': False,
                },
            )

        except Exception as e:
            logger.exception(f'SystemSummaryNode - 执行失败: {e}')
            return NodeResult(
                success=False,
                error=f'系统总结节点执行失败: {str(e)}',
            )

    def _parse_user_input(self, user_input: Any) -> Optional[Dict[str, Any]]:
        """解析用户输入"""
        if isinstance(user_input, dict):
            return user_input

        if isinstance(user_input, str):
            try:
                return json.loads(user_input)
            except (json.JSONDecodeError, TypeError):
                pass

        return None

    def _resolve_variable_value(self, context: NodeContext, value: Any) -> Any:
        """解析变量引用，保持原始类型"""
        import re

        # 如果已经是字典或列表，直接返回
        if isinstance(value, (dict, list)):
            return value

        # 如果不是字符串，返回原值
        if not isinstance(value, str):
            return value

        value = value.strip()
        if not value or value in ['{}', '[]', '']:
            return None

        # 检查是否是单个变量引用 {{node_id.variable_name}}
        single_var_pattern = r'^\{\{([^}]+)\}\}$'
        match = re.match(single_var_pattern, value)

        if match:
            var_ref = match.group(1).strip()

            # 解析 node_id.variable_name 格式
            if '.' in var_ref:
                parts = var_ref.split('.', 1)
                node_id = parts[0]
                key = parts[1]

                # 从节点输出命名空间获取
                node_outputs = context.variables.get(f'_node_{node_id}')
                if isinstance(node_outputs, dict) and key in node_outputs:
                    return node_outputs[key]

                # 直接从变量中获取
                if key in context.variables:
                    return context.variables[key]

                logger.warning(f'变量引用未找到: {var_ref}')
            else:
                # 直接变量引用
                if var_ref in context.variables:
                    return context.variables[var_ref]

                logger.warning(f'变量引用未找到: {var_ref}')

        # 不是变量引用，尝试解析为 JSON
        try:
            return json.loads(value)
        except json.JSONDecodeError:
            pass

        # 尝试 Python literal_eval
        try:
            result = ast.literal_eval(value)
            return result
        except (ValueError, SyntaxError):
            pass

        return value

    def _process_form_results(self, form_results: Any) -> List[Dict[str, Any]]:
        """处理表单结果列表"""
        forms = []

        if not form_results:
            return forms

        # 如果是单个表单结果（字典），包装成列表
        if isinstance(form_results, dict):
            form_results = [form_results]

        if not isinstance(form_results, list):
            logger.warning(f'form_results 类型不正确: {type(form_results)}')
            return forms

        for i, result in enumerate(form_results):
            if not isinstance(result, dict):
                continue

            # 尝试从不同的数据结构中提取表单信息
            form_info = self._extract_form_info(result, i)
            if form_info:
                forms.append(form_info)

        return forms

    def _extract_form_info(self, result: Dict[str, Any], index: int) -> Optional[Dict[str, Any]]:
        """从结果中提取表单信息"""
        # 直接是表单发布节点的输出
        if 'form_id' in result or 'menu_id' in result:
            return {
                'id': result.get('form_id', ''),
                'name': result.get('form_name', result.get('menu_name', f'表单{index + 1}')),
                'code': result.get('form_code', ''),
                'description': result.get('description', ''),
                'link': result.get('route_path', ''),
                'menu_id': result.get('menu_id', ''),
                'icon': result.get('menu_icon', 'lucide:file-text'),
            }

        # 循环节点的迭代结果（包含多个节点的输出）
        # 尝试从 form_publish 或 form_create 节点输出中提取
        for key in ['form_publish', 'form_create']:
            if key in result and isinstance(result[key], dict):
                sub_result = result[key]
                return {
                    'id': sub_result.get('form_id', ''),
                    'name': sub_result.get('form_name', sub_result.get('menu_name', f'表单{index + 1}')),
                    'code': sub_result.get('form_code', ''),
                    'description': sub_result.get('description', ''),
                    'link': sub_result.get('route_path', ''),
                    'menu_id': sub_result.get('menu_id', ''),
                    'icon': sub_result.get('menu_icon', 'lucide:file-text'),
                }

        # 尝试从嵌套的 publish_result 中提取
        if 'publish_result' in result and isinstance(result['publish_result'], dict):
            pub = result['publish_result']
            return {
                'id': pub.get('form_id', result.get('form_id', '')),
                'name': pub.get('form_name', pub.get('menu_name', f'表单{index + 1}')),
                'code': pub.get('form_code', result.get('form_code', '')),
                'description': pub.get('description', ''),
                'link': pub.get('route_path', ''),
                'menu_id': pub.get('menu_id', ''),
                'icon': pub.get('menu_icon', 'lucide:file-text'),
            }

        # 尝试从 _node_xxx 格式的输出中提取
        for key, value in result.items():
            if key.startswith('_node_') and isinstance(value, dict):
                if 'form_id' in value or 'route_path' in value:
                    return {
                        'id': value.get('form_id', ''),
                        'name': value.get('form_name', value.get('menu_name', f'表单{index + 1}')),
                        'code': value.get('form_code', ''),
                        'description': value.get('description', ''),
                        'link': value.get('route_path', ''),
                        'menu_id': value.get('menu_id', ''),
                        'icon': value.get('menu_icon', 'lucide:file-text'),
                    }

        return None

    def _process_app_info(self, app_info: Any) -> Optional[Dict[str, Any]]:
        """处理应用信息 - 只需要名称"""
        if not app_info:
            return None

        # 如果是字符串，直接作为名称
        if isinstance(app_info, str):
            app_name = app_info.strip()
            if not app_name:
                return None
            return {
                'name': app_name,
                'icon': 'lucide:app-window',
                'link': '/',  # 应用的基础URL
            }

        # 如果是字典，尝试提取名称
        if isinstance(app_info, dict):
            app_name = app_info.get('app_name') or app_info.get('name', '')
            if not app_name:
                return None
            return {
                'name': app_name,
                'icon': app_info.get('icon', 'lucide:app-window'),
                'link': '/',
            }

        return None

    def _process_dashboard_info(self, dashboard_info: Any) -> Optional[Dict[str, Any]]:
        """处理仪表盘信息 - 只需要名称和路径"""
        if not dashboard_info:
            return None

        # 如果是字符串，直接作为名称
        if isinstance(dashboard_info, str):
            dashboard_name = dashboard_info.strip()
            if not dashboard_name:
                return None
            return {
                'name': dashboard_name,
                'icon': 'lucide:layout-dashboard',
                'link': '',  # 没有路径信息
            }

        # 如果是字典，提取名称和路径
        if isinstance(dashboard_info, dict):
            dashboard_name = (
                dashboard_info.get('dashboard_name') or
                dashboard_info.get('menu_name') or
                dashboard_info.get('name', '')
            )
            if not dashboard_name:
                return None

            return {
                'name': dashboard_name,
                'icon': dashboard_info.get('menu_icon', 'lucide:layout-dashboard'),
                'link': dashboard_info.get('route_path', ''),
            }

        return None

    def _build_summary(
        self,
        title: str,
        app: Optional[Dict[str, Any]],
        forms: List[Dict[str, Any]],
        dashboard: Optional[Dict[str, Any]],
        show_statistics: bool,
        base_url: str,
    ) -> Dict[str, Any]:
        """构建总结数据"""
        # 计算统计信息
        total_modules = len(forms)
        if app:
            total_modules += 1
        if dashboard:
            total_modules += 1

        summary = {
            'title': title,
            'created_at': datetime.now().isoformat(),
            'statistics': {
                'total_modules': total_modules,
                'forms_count': len(forms),
                'has_app': app is not None,
                'has_dashboard': dashboard is not None,
            } if show_statistics else None,
            'app': app,
            'forms': forms,
            'dashboard': dashboard,
            'base_url': base_url,
        }

        return summary

    def _build_final_result(self, summary_data: Dict[str, Any]) -> NodeResult:
        """构建最终结果（用户确认后）"""
        forms = summary_data.get('forms', [])
        app = summary_data.get('app')
        dashboard = summary_data.get('dashboard')

        return NodeResult(
            success=True,
            output=summary_data,
            output_variables={
                'summary': summary_data,
                'total_forms': len(forms),
                'has_app': app is not None,
                'has_dashboard': dashboard is not None,
            },
        )

    @classmethod
    def get_config_schema(cls) -> Dict[str, Any]:
        """获取节点配置 Schema"""
        return {
            'type': 'object',
            'properties': {
                'app_info': {
                    'type': 'string',
                    'title': '应用信息',
                    'description': '应用信息（来自AppCreate节点），支持变量引用如 {{app_create.app_id}}',
                    'required': False,
                    'x-component': 'SmartInput',
                    'x-component-props': {
                        'placeholder': '留空则不显示应用信息',
                    },
                },
                'form_results': {
                    'type': 'string',
                    'title': '表单结果列表',
                    'description': '表单结果列表（来自循环节点或单个表单发布节点），支持变量引用如 {{loop.results}}',
                    'required': True,
                    'x-component': 'SmartInput',
                    'x-component-props': {
                        'placeholder': '{{loop.results}} 或 {{form_publish.publish_result}}',
                    },
                },
                'dashboard_info': {
                    'type': 'string',
                    'title': '仪表盘信息',
                    'description': '仪表盘信息（来自DashboardPublish节点），支持变量引用',
                    'required': False,
                    'x-component': 'SmartInput',
                    'x-component-props': {
                        'placeholder': '留空则不显示仪表盘信息',
                    },
                },
                'summary_title': {
                    'type': 'string',
                    'title': '总结标题',
                    'description': '总结页面的标题',
                    'default': '系统创建完成',
                    'x-component': 'Input',
                    'x-component-props': {
                        'placeholder': '系统创建完成',
                    },
                },
                'show_statistics': {
                    'type': 'boolean',
                    'title': '显示统计信息',
                    'description': '是否显示模块数量等统计信息',
                    'default': True,
                    'x-component': 'Switch',
                },
                'base_url': {
                    'type': 'string',
                    'title': '基础URL',
                    'description': '用于生成完整链接的基础URL（可选）',
                    'required': False,
                    'x-component': 'Input',
                    'x-component-props': {
                        'placeholder': '留空则使用相对路径',
                    },
                },
            },
            'required': ['form_results'],
        }
