#!/usr/bin/env python3
"""
XML布局分析器模块
用于解析和分析Android UI XML布局文件，以及SVG设计图的布局结构
"""

from lxml import etree
import re
from pathlib import Path
from config import Config


class XMLAnalyzer:
    """XML布局分析器"""
    
    def __init__(self):
        self.elements_data = []
        self.issues = []
        self.svg_elements = []
        self.layout_comparison_result = None
        self.config = Config.XML_ANALYSIS
    
    def parse_xml(self, xml_content):
        """解析XML内容"""
        try:
            # 如果xml_content是字符串且包含编码声明，需要特殊处理
            if isinstance(xml_content, str):
                # 移除XML声明，因为etree.fromstring不支持带编码声明的Unicode字符串
                if xml_content.strip().startswith('<?xml'):
                    # 找到XML声明的结束位置
                    declaration_end = xml_content.find('?>') + 2
                    xml_content = xml_content[declaration_end:].strip()
            
            root = etree.fromstring(xml_content)
            self.elements_data = []
            self.issues = []
            self._parse_element(root, 0)
            return True
        except Exception as e:
            print(f"❌ XML解析失败: {e}")
            return False
    
    def _parse_element(self, element, depth):
        """递归解析XML元素"""
        # 提取元素信息
        element_info = {
            'tag': element.tag,
            'depth': depth,
            'attributes': dict(element.attrib),
            'text': element.text.strip() if element.text else '',
            'children_count': len(element)
        }
        
        # 解析bounds属性
        bounds = element.get('bounds', '')
        if bounds:
            try:
                # bounds格式: [x1,y1][x2,y2]
                coords = bounds.replace('[', '').replace(']', ',').split(',')
                if len(coords) >= 4:
                    x1, y1, x2, y2 = map(int, coords[:4])
                    element_info['bounds'] = {
                        'x1': x1, 'y1': y1, 'x2': x2, 'y2': y2,
                        'width': x2 - x1, 'height': y2 - y1,
                        'center_x': (x1 + x2) // 2, 'center_y': (y1 + y2) // 2
                    }
            except:
                pass
        
        # 检查常见问题
        if self.config['check_accessibility'] or self.config['check_duplicates']:
            self._check_element_issues(element_info)
        
        self.elements_data.append(element_info)
        
        # 递归处理子元素
        for child in element:
            self._parse_element(child, depth + 1)
    
    def _check_element_issues(self, element_info):
        """检查元素问题"""
        issues = []
        
        # 检查可访问性
        if self.config['check_accessibility']:
            if element_info.get('attributes', {}).get('clickable') == 'true':
                if not element_info.get('attributes', {}).get('content-desc'):
                    issues.append("可点击元素缺少content-desc")
        
        # 检查文本大小
        if 'bounds' in element_info:
            bounds = element_info['bounds']
            min_size = self.config['min_clickable_size']
            if bounds['width'] < min_size or bounds['height'] < min_size:
                if element_info.get('attributes', {}).get('clickable') == 'true':
                    issues.append(f"可点击元素尺寸过小: {bounds['width']}x{bounds['height']}")
        
        # 检查文本内容
        text = element_info.get('text', '')
        if text:
            max_length = self.config['max_text_length']
            if len(text) > max_length:
                issues.append(f"文本过长: {len(text)}字符")
            if text.lower() in ['click here', 'button', 'text']:
                issues.append(f"文本描述不明确: '{text}'")
        
        # 检查重叠元素
        if 'bounds' in element_info:
            bounds = element_info['bounds']
            if bounds['width'] <= 0 or bounds['height'] <= 0:
                issues.append("元素尺寸无效")
        
        if issues:
            self.issues.extend([{
                'element': element_info['tag'],
                'issue': issue,
                'bounds': element_info.get('bounds', {}),
                'attributes': element_info.get('attributes', {})
            } for issue in issues])
    
    def get_statistics(self):
        """获取统计信息"""
        stats = {
            'total_elements': len(self.elements_data),
            'clickable_elements': 0,
            'text_elements': 0,
            'image_elements': 0,
            'max_depth': 0,
            'issues_count': len(self.issues)
        }
        
        for element in self.elements_data:
            if element.get('attributes', {}).get('clickable') == 'true':
                stats['clickable_elements'] += 1
            if element.get('text'):
                stats['text_elements'] += 1
            if 'Image' in element.get('tag', ''):
                stats['image_elements'] += 1
            stats['max_depth'] = max(stats['max_depth'], element.get('depth', 0))
        
        return stats
    
    def find_duplicate_ids(self):
        """查找重复的resource-id"""
        if not self.config['check_duplicates']:
            return []
        
        id_counts = {}
        duplicates = []
        
        for element in self.elements_data:
            resource_id = element.get('attributes', {}).get('resource-id')
            if resource_id:
                id_counts[resource_id] = id_counts.get(resource_id, 0) + 1
        
        for resource_id, count in id_counts.items():
            if count > 1:
                duplicates.append({
                    'resource_id': resource_id,
                    'count': count
                })
        
        return duplicates
    
    def get_accessibility_issues(self):
        """获取可访问性问题"""
        accessibility_issues = []
        
        for issue in self.issues:
            if 'content-desc' in issue['issue'] or '可访问性' in issue['issue']:
                accessibility_issues.append(issue)
        
        return accessibility_issues
    
    def export_elements_data(self, format='json'):
        """导出元素数据"""
        if format == 'json':
            import json
            return json.dumps(self.elements_data, ensure_ascii=False, indent=2)
        elif format == 'csv':
            import csv
            import io
            output = io.StringIO()
            if self.elements_data:
                fieldnames = ['tag', 'depth', 'text', 'clickable', 'resource-id']
                writer = csv.DictWriter(output, fieldnames=fieldnames)
                writer.writeheader()
                
                for element in self.elements_data:
                    row = {
                        'tag': element.get('tag', ''),
                        'depth': element.get('depth', 0),
                        'text': element.get('text', ''),
                        'clickable': element.get('attributes', {}).get('clickable', 'false'),
                        'resource-id': element.get('attributes', {}).get('resource-id', '')
                    }
                    writer.writerow(row)
            
            return output.getvalue()
        
        return str(self.elements_data)
    
    def parse_svg(self, svg_path):
        """解析SVG文件，提取布局元素信息"""
        try:
            svg_path = Path(svg_path)
            if not svg_path.exists():
                print(f"❌ SVG文件不存在: {svg_path}")
                return False
            
            with open(svg_path, 'r', encoding='utf-8') as f:
                svg_content = f.read()
            
            # 解析SVG XML
            root = etree.fromstring(svg_content.encode('utf-8'))
            
            # 获取SVG的命名空间
            namespaces = {'svg': 'http://www.w3.org/2000/svg'}
            if root.nsmap:
                namespaces.update(root.nsmap)
            
            self.svg_elements = []
            self._parse_svg_element(root, 0, namespaces)
            
            print(f"✅ SVG解析完成，找到 {len(self.svg_elements)} 个元素")
            return True
            
        except Exception as e:
            print(f"❌ SVG解析失败: {e}")
            return False
    
    def _parse_svg_element(self, element, depth, namespaces):
        """递归解析SVG元素"""
        # 获取元素标签名（去除命名空间前缀）
        tag = element.tag
        if '}' in tag:
            tag = tag.split('}')[1]
        
        # 提取元素信息
        element_info = {
            'tag': tag,
            'depth': depth,
            'attributes': dict(element.attrib),
            'text': (element.text or '').strip(),
            'children_count': len(element)
        }
        
        # 解析位置和尺寸信息
        self._extract_svg_geometry(element_info)
        
        # 解析样式信息
        self._extract_svg_styles(element_info)
        
        # 识别UI元素类型
        self._classify_svg_element(element_info)
        
        self.svg_elements.append(element_info)
        
        # 递归处理子元素
        for child in element:
            self._parse_svg_element(child, depth + 1, namespaces)
    
    def _extract_svg_geometry(self, element_info):
        """提取SVG元素的几何信息"""
        attrs = element_info['attributes']
        tag = element_info['tag']
        
        # 初始化几何信息
        geometry = {
            'x': 0, 'y': 0, 'width': 0, 'height': 0,
            'center_x': 0, 'center_y': 0
        }
        
        try:
            if tag == 'rect':
                geometry['x'] = float(attrs.get('x', 0))
                geometry['y'] = float(attrs.get('y', 0))
                geometry['width'] = float(attrs.get('width', 0))
                geometry['height'] = float(attrs.get('height', 0))
                
            elif tag == 'circle':
                cx = float(attrs.get('cx', 0))
                cy = float(attrs.get('cy', 0))
                r = float(attrs.get('r', 0))
                geometry['x'] = cx - r
                geometry['y'] = cy - r
                geometry['width'] = r * 2
                geometry['height'] = r * 2
                
            elif tag == 'ellipse':
                cx = float(attrs.get('cx', 0))
                cy = float(attrs.get('cy', 0))
                rx = float(attrs.get('rx', 0))
                ry = float(attrs.get('ry', 0))
                geometry['x'] = cx - rx
                geometry['y'] = cy - ry
                geometry['width'] = rx * 2
                geometry['height'] = ry * 2
                
            elif tag == 'line':
                x1 = float(attrs.get('x1', 0))
                y1 = float(attrs.get('y1', 0))
                x2 = float(attrs.get('x2', 0))
                y2 = float(attrs.get('y2', 0))
                geometry['x'] = min(x1, x2)
                geometry['y'] = min(y1, y2)
                geometry['width'] = abs(x2 - x1)
                geometry['height'] = abs(y2 - y1)
                
            elif tag == 'text':
                geometry['x'] = float(attrs.get('x', 0))
                geometry['y'] = float(attrs.get('y', 0))
                # 文本的宽高需要根据字体大小估算
                font_size = self._extract_font_size(attrs)
                text_length = len(element_info.get('text', ''))
                geometry['width'] = text_length * font_size * 0.6  # 估算宽度
                geometry['height'] = font_size
                
            elif tag == 'g':  # 组元素
                # 对于组元素，尝试从transform属性获取位置
                transform = attrs.get('transform', '')
                translate_match = re.search(r'translate\(([^)]+)\)', transform)
                if translate_match:
                    coords = translate_match.group(1).split(',')
                    if len(coords) >= 2:
                        geometry['x'] = float(coords[0].strip())
                        geometry['y'] = float(coords[1].strip())
            
            # 计算中心点
            geometry['center_x'] = geometry['x'] + geometry['width'] / 2
            geometry['center_y'] = geometry['y'] + geometry['height'] / 2
            
            element_info['geometry'] = geometry
            
        except (ValueError, TypeError):
            # 如果解析失败，使用默认值
            element_info['geometry'] = geometry
    
    def _extract_font_size(self, attrs):
        """提取字体大小"""
        # 从style属性中提取
        style = attrs.get('style', '')
        font_size_match = re.search(r'font-size:\s*(\d+(?:\.\d+)?)', style)
        if font_size_match:
            return float(font_size_match.group(1))
        
        # 从font-size属性中提取
        font_size = attrs.get('font-size', '12')
        try:
            return float(re.sub(r'[^\d.]', '', font_size))
        except:
            return 12.0  # 默认字体大小
    
    def _extract_svg_styles(self, element_info):
        """提取SVG元素的样式信息"""
        attrs = element_info['attributes']
        styles = {}
        
        # 解析style属性
        style_attr = attrs.get('style', '')
        if style_attr:
            for style_rule in style_attr.split(';'):
                if ':' in style_rule:
                    key, value = style_rule.split(':', 1)
                    styles[key.strip()] = value.strip()
        
        # 直接的样式属性
        style_attrs = ['fill', 'stroke', 'stroke-width', 'opacity', 'font-family', 'font-size', 'color']
        for attr in style_attrs:
            if attr in attrs:
                styles[attr] = attrs[attr]
        
        element_info['styles'] = styles
    
    def _classify_svg_element(self, element_info):
        """分类SVG元素，识别可能的UI组件类型"""
        tag = element_info['tag']
        attrs = element_info['attributes']
        styles = element_info.get('styles', {})
        text = element_info.get('text', '')
        
        ui_type = 'unknown'
        
        if tag == 'text' or text:
            ui_type = 'text'
        elif tag == 'rect':
            # 判断是否为按钮
            if styles.get('fill') and styles.get('stroke'):
                ui_type = 'button'
            else:
                ui_type = 'container'
        elif tag == 'circle' or tag == 'ellipse':
            ui_type = 'button'  # 圆形通常是按钮
        elif tag == 'image':
            ui_type = 'image'
        elif tag == 'g':
            ui_type = 'group'
        elif tag == 'path':
            ui_type = 'icon'  # path通常用于图标
        
        element_info['ui_type'] = ui_type
    
    def compare_layouts(self, svg_path):
        """比较XML布局与SVG设计图的结构"""
        if not self.elements_data:
            print("❌ 请先解析XML布局")
            return None
        
        if not self.parse_svg(svg_path):
            return None
        
        try:
            # 分析XML中的UI元素
            xml_ui_elements = self._extract_xml_ui_elements()
            
            # 分析SVG中的UI元素
            svg_ui_elements = self._extract_svg_ui_elements()
            
            # 进行布局比对
            comparison_result = {
                'xml_elements_count': len(xml_ui_elements),
                'svg_elements_count': len(svg_ui_elements),
                'matched_elements': [],
                'unmatched_xml': [],
                'unmatched_svg': [],
                'layout_similarity': 0.0,
                'position_differences': [],
                'size_differences': []
            }
            
            # 匹配相似的元素
            self._match_ui_elements(xml_ui_elements, svg_ui_elements, comparison_result)
            
            # 计算布局相似度
            self._calculate_layout_similarity(comparison_result)
            
            self.layout_comparison_result = comparison_result
            
            print(f"📊 布局比对完成:")
            print(f"   XML元素: {comparison_result['xml_elements_count']}个")
            print(f"   SVG元素: {comparison_result['svg_elements_count']}个")
            print(f"   匹配元素: {len(comparison_result['matched_elements'])}个")
            print(f"   布局相似度: {comparison_result['layout_similarity']:.1%}")
            
            return comparison_result
            
        except Exception as e:
            print(f"❌ 布局比对失败: {e}")
            return None
    
    def _extract_xml_ui_elements(self):
        """从XML数据中提取UI元素"""
        ui_elements = []
        
        for element in self.elements_data:
            # 过滤掉容器元素，只保留实际的UI组件
            if self._is_ui_component(element):
                ui_element = {
                    'type': self._classify_xml_element(element),
                    'text': element.get('text', ''),
                    'bounds': element.get('bounds', {}),
                    'attributes': element.get('attributes', {}),
                    'source': 'xml'
                }
                ui_elements.append(ui_element)
        
        return ui_elements
    
    def _extract_svg_ui_elements(self):
        """从SVG数据中提取UI元素"""
        ui_elements = []
        
        for element in self.svg_elements:
            if element['ui_type'] != 'unknown':
                ui_element = {
                    'type': element['ui_type'],
                    'text': element.get('text', ''),
                    'geometry': element.get('geometry', {}),
                    'styles': element.get('styles', {}),
                    'source': 'svg'
                }
                ui_elements.append(ui_element)
        
        return ui_elements
    
    def _is_ui_component(self, element):
        """判断XML元素是否为UI组件"""
        tag = element.get('tag', '')
        attrs = element.get('attributes', {})
        
        # 排除纯容器元素
        container_tags = ['LinearLayout', 'RelativeLayout', 'FrameLayout', 'ConstraintLayout']
        if any(container in tag for container in container_tags):
            return False
        
        # 包含文本或可点击的元素
        if element.get('text') or attrs.get('clickable') == 'true':
            return True
        
        # 特定的UI组件
        ui_tags = ['Button', 'TextView', 'ImageView', 'EditText', 'CheckBox', 'RadioButton']
        return any(ui_tag in tag for ui_tag in ui_tags)
    
    def _classify_xml_element(self, element):
        """分类XML元素"""
        tag = element.get('tag', '')
        attrs = element.get('attributes', {})
        
        if 'Button' in tag:
            return 'button'
        elif 'TextView' in tag or element.get('text'):
            return 'text'
        elif 'ImageView' in tag:
            return 'image'
        elif 'EditText' in tag:
            return 'input'
        elif attrs.get('clickable') == 'true':
            return 'button'
        else:
            return 'container'
    
    def _match_ui_elements(self, xml_elements, svg_elements, result):
        """匹配XML和SVG中的UI元素"""
        matched_xml = set()
        matched_svg = set()
        
        for i, xml_elem in enumerate(xml_elements):
            best_match = None
            best_score = 0
            
            for j, svg_elem in enumerate(svg_elements):
                if j in matched_svg:
                    continue
                
                score = self._calculate_element_similarity(xml_elem, svg_elem)
                if score > best_score and score > 0.5:  # 相似度阈值
                    best_score = score
                    best_match = j
            
            if best_match is not None:
                matched_xml.add(i)
                matched_svg.add(best_match)
                
                match_info = {
                    'xml_element': xml_elements[i],
                    'svg_element': svg_elements[best_match],
                    'similarity': best_score,
                    'position_diff': self._calculate_position_difference(
                        xml_elements[i], svg_elements[best_match]
                    ),
                    'size_diff': self._calculate_size_difference(
                        xml_elements[i], svg_elements[best_match]
                    )
                }
                result['matched_elements'].append(match_info)
        
        # 记录未匹配的元素
        result['unmatched_xml'] = [xml_elements[i] for i in range(len(xml_elements)) if i not in matched_xml]
        result['unmatched_svg'] = [svg_elements[j] for j in range(len(svg_elements)) if j not in matched_svg]
    
    def _calculate_element_similarity(self, xml_elem, svg_elem):
        """计算两个元素的相似度"""
        score = 0
        
        # 类型匹配
        if xml_elem['type'] == svg_elem['type']:
            score += 0.4
        
        # 文本匹配
        xml_text = xml_elem.get('text', '').strip().lower()
        svg_text = svg_elem.get('text', '').strip().lower()
        
        if xml_text and svg_text:
            if xml_text == svg_text:
                score += 0.4
            elif xml_text in svg_text or svg_text in xml_text:
                score += 0.2
        elif not xml_text and not svg_text:
            score += 0.2
        
        # 位置相似度（相对位置）
        position_score = self._calculate_relative_position_similarity(xml_elem, svg_elem)
        score += position_score * 0.2
        
        return min(score, 1.0)
    
    def _calculate_relative_position_similarity(self, xml_elem, svg_elem):
        """计算相对位置相似度"""
        # 这里简化处理，实际应该考虑屏幕尺寸的缩放
        return 0.5  # 暂时返回中等相似度
    
    def _calculate_position_difference(self, xml_elem, svg_elem):
        """计算位置差异"""
        xml_bounds = xml_elem.get('bounds', {})
        svg_geometry = svg_elem.get('geometry', {})
        
        if not xml_bounds or not svg_geometry:
            return {'x': 0, 'y': 0}
        
        return {
            'x': abs(xml_bounds.get('center_x', 0) - svg_geometry.get('center_x', 0)),
            'y': abs(xml_bounds.get('center_y', 0) - svg_geometry.get('center_y', 0))
        }
    
    def _calculate_size_difference(self, xml_elem, svg_elem):
        """计算尺寸差异"""
        xml_bounds = xml_elem.get('bounds', {})
        svg_geometry = svg_elem.get('geometry', {})
        
        if not xml_bounds or not svg_geometry:
            return {'width': 0, 'height': 0}
        
        return {
            'width': abs(xml_bounds.get('width', 0) - svg_geometry.get('width', 0)),
            'height': abs(xml_bounds.get('height', 0) - svg_geometry.get('height', 0))
        }
    
    def _calculate_layout_similarity(self, result):
        """计算整体布局相似度"""
        total_elements = max(result['xml_elements_count'], result['svg_elements_count'])
        if total_elements == 0:
            result['layout_similarity'] = 0.0
            return
        
        matched_count = len(result['matched_elements'])
        base_similarity = matched_count / total_elements
        
        # 考虑匹配质量
        if result['matched_elements']:
            avg_match_quality = sum(match['similarity'] for match in result['matched_elements']) / len(result['matched_elements'])
            result['layout_similarity'] = base_similarity * avg_match_quality
        else:
            result['layout_similarity'] = 0.0
    
    def get_layout_comparison_summary(self):
        """获取布局比对摘要"""
        if not self.layout_comparison_result:
            return "未进行布局比对"
        
        result = self.layout_comparison_result
        summary = f"""
📊 布局比对摘要:
   • XML元素数量: {result['xml_elements_count']}
   • SVG元素数量: {result['svg_elements_count']}
   • 匹配元素数量: {len(result['matched_elements'])}
   • 布局相似度: {result['layout_similarity']:.1%}
   • 未匹配XML元素: {len(result['unmatched_xml'])}
   • 未匹配SVG元素: {len(result['unmatched_svg'])}
"""
        
        if result['layout_similarity'] >= 0.8:
            summary += "\n✅ 布局高度一致"
        elif result['layout_similarity'] >= 0.6:
            summary += "\n⚠️  布局基本一致，有少量差异"
        else:
            summary += "\n❌ 布局差异较大，建议检查"
        
        return summary