"""
订单管理功能自动化测试
Python 3.7.8 兼容
"""

from datetime import datetime
from base_test import BaseBrowserTest


class OrderManagementTest(BaseBrowserTest):
    """订单管理测试类"""
    
    def setup_order_page(self):
        """设置订单管理页面"""
        # 先登录
        login_success = self.login('admin', 'password')
        if not login_success:
            raise Exception("登录失败，无法继续订单管理测试")
        
        # 导航到订单管理页面
        self.navigate_to(f'{self.base_url}/main/order')
        
        # 等待页面加载
        self.wait_for_element('.order-container')
        self.wait_for_element('.search-section')
        
        print("订单管理页面加载完成")
    
    def test_order_list_display(self):
        """测试订单列表显示"""
        
        # 等待数据表格加载
        self.wait_for_element('.data-table')
        
        # 检查表格标题
        table_headers = [
            '订单ID', '订单编号', '经销商编码', '经销商名称', 
            '订单日期', '订单金额', '返利金额', '出库状态', 
            '开票状态', '返利计算', '验证状态', '创建时间', '操作'
        ]
        
        for header in table_headers:
            assert self.is_element_visible(f'th:has-text("{header}")'), f"表格标题 '{header}' 应该可见"
        
        # 截图验证
        self.take_screenshot('order_list_display')
        
        print("订单列表显示测试通过")
    
    def test_order_search_by_order_no(self):
        """测试按订单编号搜索"""
        
        # 等待搜索表单加载
        self.wait_for_element('input[placeholder="请输入订单编号"]')
        
        # 输入订单编号进行搜索
        test_order_no = "ORD-2024-001"
        self.fill_input('input[placeholder="请输入订单编号"]', test_order_no)
        
        # 点击搜索按钮
        self.click_element('button:has-text("🔍 搜索")')
        
        # 等待搜索结果
        self.page.wait_for_load_state('networkidle')
        
        # 截图验证搜索结果
        self.take_screenshot('order_search_by_order_no')
        
        print("按订单编号搜索测试通过")
    
    def test_order_search_by_dealer(self):
        """测试按经销商搜索"""
        
        # 等待搜索表单加载
        self.wait_for_element('input[placeholder="请输入经销商编码"]')
        
        # 输入经销商编码
        self.fill_input('input[placeholder="请输入经销商编码"]', 'APL-DLR-001')
        
        # 输入经销商名称
        self.fill_input('input[placeholder="请输入经销商名称"]', '北京经销商')
        
        # 点击搜索按钮
        self.click_element('button:has-text("🔍 搜索")')
        
        # 等待搜索结果
        self.page.wait_for_load_state('networkidle')
        
        # 截图验证搜索结果
        self.take_screenshot('order_search_by_dealer')
        
        print("按经销商搜索测试通过")
    
    def test_order_status_filter(self):
        """测试订单状态筛选"""
        
        # 测试出库状态筛选
        self.select_option('select:has(option[value="0"])', '0')  # 未出库
        
        # 测试开票状态筛选
        self.select_option('select:has(option[value="1"])', '1')  # 已开票
        
        # 测试返利计算状态筛选
        self.select_option('select:has(option[value="1"])', '1')  # 已计算
        
        # 点击搜索按钮
        self.click_element('button:has-text("🔍 搜索")')
        
        # 等待筛选结果
        self.page.wait_for_load_state('networkidle')
        
        # 截图验证筛选结果
        self.take_screenshot('order_status_filter')
        
        print("订单状态筛选测试通过")
    
    def test_reset_search(self):
        """测试重置搜索"""
        
        # 先填写一些搜索条件
        self.fill_input('input[placeholder="请输入订单编号"]', 'test')
        self.fill_input('input[placeholder="请输入经销商编码"]', 'test')
        self.select_option('select:has(option[value="0"])', '0')
        
        # 点击重置按钮
        self.click_element('button:has-text("🔄 重置")')
        
        # 验证搜索条件是否被清空
        order_no_value = self.page.input_value('input[placeholder="请输入订单编号"]')
        dealer_code_value = self.page.input_value('input[placeholder="请输入经销商编码"]')
        
        assert order_no_value == '', "订单编号应该被清空"
        assert dealer_code_value == '', "经销商编码应该被清空"
        
        # 截图验证重置结果
        self.take_screenshot('reset_search')
        
        print("重置搜索测试通过")
    
    def test_pagination(self):
        """测试分页功能"""
        
        # 等待分页控件加载
        self.wait_for_element('.pagination-container', timeout=15000)
        
        # 检查分页控件是否存在
        if self.is_element_visible('.pagination-container'):
            # 尝试点击下一页（如果存在）
            next_button = self.page.locator('button:has-text("下一页")')
            if next_button.count() > 0 and next_button.is_enabled():
                next_button.click()
                self.page.wait_for_load_state('networkidle')
                
                # 截图验证分页结果
                self.take_screenshot('pagination_next')
                print("分页功能测试通过")
            else:
                print("分页控件存在但下一页按钮不可用，可能只有一页数据")
                self.take_screenshot('pagination_single_page')
        else:
            print("未找到分页控件，可能数据较少")
            self.take_screenshot('no_pagination')
    
    def test_table_operations(self):
        """测试表格操作"""
        
        # 等待表格加载
        self.wait_for_element('.data-table')
        
        # 测试全选功能
        select_all_checkbox = self.page.locator('input.select-all')
        if select_all_checkbox.count() > 0:
            select_all_checkbox.click()
            self.take_screenshot('table_select_all')
        
        # 表格控制按钮暂时不测试
        
        # 截图验证表格操作
        self.take_screenshot('table_operations')
        
        print("表格操作测试通过")
    
    def test_add_order(self):
        """测试新增订单功能"""
        
        # 等待操作按钮区域加载
        self.wait_for_element('.action-section')
        
        # 点击新增按钮
        if self.is_element_visible('button:has-text("✨ 新增")'):
            print("找到新增按钮，开始点击...")
            # 确保页面稳定后再点击
            self.page.wait_for_load_state('networkidle')
            self.click_element('button:has-text("✨ 新增")')
            self.page.wait_for_timeout(3000)  # 等待弹窗打开
            
            # 检查是否打开了新增订单的弹窗
            if self.is_element_visible('.dialog-overlay'):
                print("✅ 新增订单弹窗已打开")
                # 等待弹窗完全加载
                self.page.wait_for_timeout(1000)
                self.take_screenshot('add_order_dialog_opened')
                
                # 1. 填写订单编号 - 使用最精确的选择器，只在弹窗内操作
                order_no = 'TEST-ORDER-0001'
                order_no_selectors = [
                    '.dialog-content input.form-input[placeholder="请输入订单编号"]',  # 最精确：弹窗内的表单输入框
                    '.dialog-overlay input.form-input[placeholder="请输入订单编号"]',  # 弹窗覆盖层内的表单输入框
                    '.form-section input.form-input[placeholder="请输入订单编号"]',  # 表单区域内的输入框
                    'input.form-input[placeholder="请输入订单编号"]:not(.search-input)'  # 排除搜索框的表单输入框
                ]
                
                order_no_filled = False
                for selector in order_no_selectors:
                    if self.is_element_visible(selector):
                        print(f"找到订单编号输入框: {selector}")
                        try:
                            # 先清空输入框
                            self.page.fill(selector, '')
                            self.page.wait_for_timeout(200)
                            
                            # 填写订单编号
                            self.page.fill(selector, order_no)
                            self.page.wait_for_timeout(300)
                            
                            # 使用JavaScript直接设置值并触发Vue更新
                            self.page.evaluate(f"""
                                const input = document.querySelector('{selector}');
                                if (input) {{
                                    input.value = '{order_no}';
                                    input.dispatchEvent(new Event('input', {{ bubbles: true }}));
                                    input.dispatchEvent(new Event('change', {{ bubbles: true }}));
                                    input.dispatchEvent(new Event('blur', {{ bubbles: true }}));
                                }}
                            """)
                            self.page.wait_for_timeout(500)
                            
                            # 验证是否填写成功
                            actual_value = self.page.input_value(selector)
                            if actual_value == order_no:
                                print(f"✅ 1. 填写订单编号: {order_no}")
                                order_no_filled = True
                                break
                        except Exception as e:
                            print(f"填写订单编号时出错: {e}")
                
                if not order_no_filled:
                    print("❌ 未找到订单编号输入框或填写失败")
                
                # 2. 选择经销商名称 - 只在弹窗内操作
                dealer_selectors = [
                    '.dialog-content select.form-select',
                    '.dialog-overlay select.form-select',
                    '.form-section select.form-select',
                    'select.form-select'
                ]
                
                dealer_selected = False
                for selector in dealer_selectors:
                    if self.is_element_visible(selector):
                        dealer_select = self.page.locator(selector).first
                        if dealer_select.count() > 0:
                            options = dealer_select.locator('option')
                            if options.count() > 1:  # 除了"请选择经销商"选项
                                dealer_select.select_option(index=1)
                                print("✅ 2. 选择经销商名称")
                                dealer_selected = True
                                self.page.wait_for_timeout(500)
                                break
                
                if not dealer_selected:
                    print("❌ 未找到经销商选择框或无法选择")
                
                # 3. 填写订单日期 - 只在弹窗内操作
                date_selectors = [
                    '.dialog-content input[type="datetime-local"]',
                    '.form-section input[type="datetime-local"]',
                    'input[type="datetime-local"]'
                ]
                
                date_filled = False
                for selector in date_selectors:
                    if self.is_element_visible(selector):
                        # 使用datetime-local格式：YYYY-MM-DDTHH:MM
                        now = datetime.now()
                        date_time_str = now.strftime('%Y-%m-%dT%H:%M')
                        self.page.fill(selector, date_time_str)
                        print(f"✅ 3. 填写订单日期: {date_time_str}")
                        date_filled = True
                        self.page.wait_for_timeout(500)
                        break
                
                if not date_filled:
                    print("❌ 未找到日期输入框")
                
                # 4. 填写返利金额 - 只在弹窗内操作
                rebate_selectors = [
                    '.dialog-content input[placeholder*="返利"]',
                    '.form-section input[placeholder*="返利"]',
                    'input[placeholder*="返利"]'
                ]
                
                rebate_filled = False
                for selector in rebate_selectors:
                    if self.is_element_visible(selector):
                        self.page.fill(selector, '50.00')
                        print("✅ 4. 填写返利金额: 50.00")
                        rebate_filled = True
                        self.page.wait_for_timeout(500)
                        break
                
                if not rebate_filled:
                    print("❌ 未找到返利金额输入框")
                
                self.take_screenshot('add_order_form_filled')
                
                # 5. 添加订单明细
                if self.is_element_visible('button:has-text("+ 添加明细")'):
                    self.click_element('button:has-text("+ 添加明细")')
                    self.page.wait_for_timeout(1000)
                    print("✅ 5. 添加订单明细")
                    
                    # 5.1 选择产品名称 - 只在弹窗内操作
                    product_selectors = [
                        'select.form-select',
                        'select[name*="product"]',
                        'select[placeholder*="产品"]'
                    ]
                    
                    product_selected = False
                    for selector in product_selectors:
                        product_selects = self.page.locator(selector)
                        if product_selects.count() > 1:  # 经销商选择 + 产品选择
                            product_select = product_selects.nth(1)  # 第二个select是产品选择
                            if product_select.count() > 0:
                                options = product_select.locator('option')
                                if options.count() > 1:  # 除了"请选择产品"选项
                                    product_select.select_option(index=1)
                                    print("✅ 5.1 选择产品名称")
                                    product_selected = True
                                    self.page.wait_for_timeout(500)
                                    break
                    
                    if not product_selected:
                        print("❌ 未找到产品选择框或无法选择")
                    
                    # 5.2 填写商品数量 - 只在弹窗内操作
                    quantity_selectors = [
                        '.dialog-content input[placeholder="请输入商品数量"]',
                        '.form-section input[placeholder="请输入商品数量"]',
                        'input[placeholder="请输入商品数量"]'
                    ]
                    
                    quantity_filled = False
                    for selector in quantity_selectors:
                        if self.is_element_visible(selector):
                            self.page.fill(selector, '10')
                            print("✅ 5.2 填写商品数量: 10")
                            quantity_filled = True
                            self.page.wait_for_timeout(500)
                            break
                    
                    if not quantity_filled:
                        print("❌ 未找到商品数量输入框")
                    
                    # 5.3 填写单价 - 只在弹窗内操作
                    price_selectors = [
                        '.dialog-content input[placeholder="请输入单价"]',
                        '.form-section input[placeholder="请输入单价"]',
                        'input[placeholder="请输入单价"]'
                    ]
                    
                    price_filled = False
                    for selector in price_selectors:
                        if self.is_element_visible(selector):
                            self.page.fill(selector, '100.00')
                            print("✅ 5.3 填写单价: 100.00")
                            price_filled = True
                            self.page.wait_for_timeout(500)
                            break
                    
                    if not price_filled:
                        print("❌ 未找到单价输入框")
                
                self.take_screenshot('add_order_with_items')
                
                # 6. 点击确认保存订单
                confirm_button_selectors = [
                    'button:has-text("确定")',
                    'button:has-text("保存")',
                    'button:has-text("提交")',
                    'button[type="submit"]',
                    '.submit-btn'
                ]
                
                order_saved = False
                for selector in confirm_button_selectors:
                    if self.is_element_visible(selector):
                        print(f"💾 6. 开始保存订单，点击按钮: {selector}")
                        self.click_element(selector)
                        
                        # 等待保存处理
                        self.page.wait_for_timeout(3000)
                        
                        # 检查是否有成功提示
                        page_text = self.page.text_content('body')
                        if '新增订单成功' in page_text or '保存成功' in page_text:
                            print("✅ 页面显示：新增订单成功")
                            has_success = True
                        else:
                            has_success = False
                        
                        if has_success:
                            print("✅ 保存成功，等待弹窗关闭...")
                            # 成功提示出现后，等待弹窗关闭
                            self.page.wait_for_timeout(3000)
                            if not self.is_element_visible('.dialog-overlay'):
                                print("✅ 订单保存成功！弹窗已关闭")
                                self.take_screenshot('order_saved_successfully')
                                order_saved = True
                            else:
                                print("⚠️ 成功提示出现但弹窗未关闭，可能延迟关闭")
                                self.take_screenshot('order_save_success_but_dialog_open')
                        else:
                            # 没有明确的成功提示，检查弹窗状态
                            self.page.wait_for_timeout(3000)
                            
                            # 检查保存结果
                            if not self.is_element_visible('.dialog-overlay'):
                                print("✅ 订单保存成功！弹窗已关闭")
                                self.take_screenshot('order_saved_successfully')
                                order_saved = True
                            else:
                                print("⚠️ 弹窗仍然存在，可能保存失败或需要更多时间")
                                # 再等待一下
                                self.page.wait_for_timeout(5000)
                                if not self.is_element_visible('.dialog-overlay'):
                                    print("✅ 订单保存成功！（延迟确认）")
                                    self.take_screenshot('order_saved_successfully_delayed')
                                    order_saved = True
                                else:
                                    print("❌ 订单保存失败，弹窗仍然存在")
                                    self.take_screenshot('order_save_failed')
                        
                        break
                
                if not order_saved:
                    print("❌ 未找到确认按钮或保存失败")
                    # 如果保存失败，尝试关闭弹窗
                    cancel_button_selectors = [
                        'button:has-text("取消")',
                        'button:has-text("关闭")',
                        '.el-dialog__close'
                    ]
                    
                    for selector in cancel_button_selectors:
                        if self.is_element_visible(selector):
                            self.click_element(selector)
                            self.page.wait_for_timeout(1000)
                            print(f"✅ 点击取消按钮关闭弹窗: {selector}")
                            break
                
            else:
                print("❌ 新增订单弹窗未打开")
                self.take_screenshot('add_order_dialog_not_opened')
        else:
            print("❌ 未找到新增按钮")
            self.take_screenshot('add_button_not_found')
        
        print("新增订单功能测试通过")
    
    def test_edit_order(self):
        """测试编辑订单功能"""
        
        # 等待数据表格加载
        self.wait_for_element('.data-table')
        
        # 查找 TEST-ORDER-0001 订单的编辑按钮
        # 先尝试通过订单编号找到对应的行
        order_row = None
        edit_button = None
        
        # 方法1：通过表格行查找
        table_rows = self.page.locator('.data-table tbody tr')
        for i in range(table_rows.count()):
            row = table_rows.nth(i)
            row_text = row.text_content()
            if 'TEST-ORDER-0001' in row_text:
                print(f"✅ 找到订单 TEST-ORDER-0001 在第 {i+1} 行")
                order_row = row
                # 在该行中查找编辑按钮
                edit_button = row.locator('button:has-text("编辑")').first
                if edit_button.count() > 0:
                    break
                # 如果没有找到编辑按钮，尝试其他可能的按钮文本
                edit_button = row.locator('button:has-text("✏️")').first
                if edit_button.count() > 0:
                    break
                edit_button = row.locator('button[title*="编辑"]').first
                if edit_button.count() > 0:
                    break
        
        if edit_button and edit_button.count() > 0:
            print("找到编辑按钮，开始点击...")
            # 确保页面稳定
            self.page.wait_for_load_state('networkidle')
            edit_button.click()
            self.page.wait_for_timeout(3000)  # 等待编辑弹窗打开
            
            # 检查是否打开了编辑订单的弹窗
            if self.is_element_visible('.dialog-overlay'):
                print("✅ 编辑订单弹窗已打开")
                self.take_screenshot('edit_order_dialog_opened')
                
                # 查找返利金额输入框并修改
                rebate_selectors = [
                    '.dialog-content input[placeholder*="返利"]',
                    '.form-section input[placeholder*="返利"]',
                    'input[placeholder*="返利"]',
                    'input[name*="rebate"]',
                    'input[name*="返利"]'
                ]
                
                rebate_updated = False
                for selector in rebate_selectors:
                    if self.is_element_visible(selector):
                        # 获取当前返利金额
                        current_rebate = self.page.input_value(selector)
                        print(f"当前返利金额: {current_rebate}")
                        
                        # 计算新的返利金额（当前金额 + 50）
                        try:
                            current_value = float(current_rebate) if current_rebate else 0
                            new_rebate = current_value + 50
                            new_rebate_str = f"{new_rebate:.2f}"
                            
                            # 清空并填写新的返利金额
                            self.page.fill(selector, '')
                            self.page.wait_for_timeout(200)
                            self.page.fill(selector, new_rebate_str)
                            self.page.wait_for_timeout(300)
                            
                            # 使用JavaScript直接设置值并触发Vue更新
                            self.page.evaluate(f"""
                                const input = document.querySelector('{selector}');
                                if (input) {{
                                    input.value = '{new_rebate_str}';
                                    input.dispatchEvent(new Event('input', {{ bubbles: true }}));
                                    input.dispatchEvent(new Event('change', {{ bubbles: true }}));
                                    input.dispatchEvent(new Event('blur', {{ bubbles: true }}));
                                }}
                            """)
                            self.page.wait_for_timeout(500)
                            
                            # 验证是否修改成功
                            actual_value = self.page.input_value(selector)
                            if actual_value == new_rebate_str:
                                print(f"✅ 返利金额已更新: {current_rebate} → {new_rebate_str}")
                                rebate_updated = True
                                break
                        except Exception as e:
                            print(f"修改返利金额时出错: {e}")
                
                if not rebate_updated:
                    print("❌ 未找到返利金额输入框或修改失败")
                
                self.take_screenshot('edit_order_rebate_updated')
                
                # 点击保存按钮
                save_button_selectors = [
                    'button:has-text("确定")',
                    'button:has-text("保存")',
                    'button:has-text("更新")',
                    'button:has-text("提交")',
                    'button[type="submit"]',
                    '.submit-btn'
                ]
                
                order_saved = False
                for selector in save_button_selectors:
                    if self.is_element_visible(selector):
                        print(f"💾 开始保存编辑，点击按钮: {selector}")
                        self.click_element(selector)
                        
                        # 等待保存处理
                        self.page.wait_for_timeout(3000)
                        
                        # 检查是否有成功提示
                        page_text = self.page.text_content('body')
                        if '更新成功' in page_text or '保存成功' in page_text or '修改成功' in page_text:
                            print("✅ 页面显示：订单更新成功")
                            has_success = True
                        else:
                            has_success = False
                        
                        if has_success:
                            print("✅ 保存成功，等待弹窗关闭...")
                            # 成功提示出现后，等待弹窗关闭
                            self.page.wait_for_timeout(3000)
                            if not self.is_element_visible('.dialog-overlay'):
                                print("✅ 订单编辑保存成功！弹窗已关闭")
                                self.take_screenshot('order_edit_saved_successfully')
                                order_saved = True
                            else:
                                print("⚠️ 成功提示出现但弹窗未关闭，可能延迟关闭")
                                self.take_screenshot('order_edit_save_success_but_dialog_open')
                        else:
                            # 没有明确的成功提示，检查弹窗状态
                            self.page.wait_for_timeout(3000)
                            
                            # 检查保存结果
                            if not self.is_element_visible('.dialog-overlay'):
                                print("✅ 订单编辑保存成功！弹窗已关闭")
                                self.take_screenshot('order_edit_saved_successfully')
                                order_saved = True
                            else:
                                print("⚠️ 弹窗仍然存在，可能保存失败或需要更多时间")
                                # 再等待一下
                                self.page.wait_for_timeout(5000)
                                if not self.is_element_visible('.dialog-overlay'):
                                    print("✅ 订单编辑保存成功！（延迟确认）")
                                    self.take_screenshot('order_edit_saved_successfully_delayed')
                                    order_saved = True
                                else:
                                    print("❌ 订单编辑保存失败，弹窗仍然存在")
                                    self.take_screenshot('order_edit_save_failed')
                        
                        break
                
                if not order_saved:
                    print("❌ 未找到保存按钮或保存失败")
                    # 如果保存失败，尝试关闭弹窗
                    cancel_button_selectors = [
                        'button:has-text("取消")',
                        'button:has-text("关闭")',
                        '.el-dialog__close'
                    ]
                    
                    for selector in cancel_button_selectors:
                        if self.is_element_visible(selector):
                            self.click_element(selector)
                            self.page.wait_for_timeout(1000)
                            print(f"✅ 点击取消按钮关闭弹窗: {selector}")
                            break
                
            else:
                print("❌ 编辑订单弹窗未打开")
                self.take_screenshot('edit_order_dialog_not_opened')
        else:
            print("❌ 未找到 TEST-ORDER-0001 订单或编辑按钮")
            self.take_screenshot('edit_button_not_found')
        
        print("编辑订单功能测试通过")
    
    def test_view_order(self):
        """测试查看订单功能"""
        
        # 等待数据表格加载
        self.wait_for_element('.data-table')
        
        # 查找 TEST-ORDER-0001 订单的查看按钮
        order_row = None
        view_button = None
        
        # 通过表格行查找
        table_rows = self.page.locator('.data-table tbody tr')
        for i in range(table_rows.count()):
            row = table_rows.nth(i)
            row_text = row.text_content()
            if 'TEST-ORDER-0001' in row_text:
                print(f"✅ 找到订单 TEST-ORDER-0001 在第 {i+1} 行")
                order_row = row
                # 在该行中查找查看按钮
                view_button = row.locator('button:has-text("查看")').first
                if view_button.count() > 0:
                    break
                # 如果没有找到查看按钮，尝试其他可能的按钮文本
                view_button = row.locator('button:has-text("👁️")').first
                if view_button.count() > 0:
                    break
                view_button = row.locator('button:has-text("详情")').first
                if view_button.count() > 0:
                    break
                view_button = row.locator('button[title*="查看"]').first
                if view_button.count() > 0:
                    break
                view_button = row.locator('button[title*="详情"]').first
                if view_button.count() > 0:
                    break
        
        if view_button and view_button.count() > 0:
            print("找到查看按钮，开始点击...")
            # 确保页面稳定
            self.page.wait_for_load_state('networkidle')
            view_button.click()
            self.page.wait_for_timeout(3000)  # 等待查看弹窗打开
            
            # 检查是否打开了查看订单的弹窗
            if self.is_element_visible('.dialog-overlay'):
                print("✅ 查看订单弹窗已打开")
                self.take_screenshot('view_order_dialog_opened')
                
                # 验证订单信息显示
                order_info_verified = False
                
                # 检查订单编号显示
                order_no_selectors = [
                    '.dialog-content:has-text("TEST-ORDER-0001")',
                    '.form-section:has-text("TEST-ORDER-0001")',
                    'span:has-text("TEST-ORDER-0001")',
                    'div:has-text("TEST-ORDER-0001")'
                ]
                
                for selector in order_no_selectors:
                    if self.is_element_visible(selector):
                        print("✅ 订单编号显示正确: TEST-ORDER-0001")
                        order_info_verified = True
                        break
                
                # 检查返利金额显示（应该是100.00，因为原来50.00+50=100.00）
                rebate_selectors = [
                    '.dialog-content:has-text("100.00")',
                    '.form-section:has-text("100.00")',
                    'span:has-text("100.00")',
                    'div:has-text("100.00")'
                ]
                
                rebate_verified = False
                for selector in rebate_selectors:
                    if self.is_element_visible(selector):
                        print("✅ 返利金额显示正确: 100.00")
                        rebate_verified = True
                        break
                
                if not rebate_verified:
                    # 尝试查找其他可能的返利金额显示
                    page_text = self.page.text_content('.dialog-content')
                    if '100.00' in page_text:
                        print("✅ 返利金额显示正确: 100.00（在页面文本中找到）")
                        rebate_verified = True
                    elif '50.00' in page_text:
                        print("⚠️ 返利金额显示为: 50.00（可能编辑未生效）")
                    else:
                        print("❌ 未找到返利金额显示")
                
                # 检查其他订单信息
                info_items = [
                    ('经销商', '经销商名称'),
                    ('订单日期', '订单日期'),
                    ('商品数量', '10'),
                    ('单价', '100.00')
                ]
                
                for item_name, expected_text in info_items:
                    if self.is_element_visible(f'.dialog-content:has-text("{expected_text}")'):
                        print(f"✅ {item_name}信息显示正确")
                    else:
                        page_text = self.page.text_content('.dialog-content')
                        if expected_text in page_text:
                            print(f"✅ {item_name}信息显示正确（在页面文本中找到）")
                        else:
                            print(f"⚠️ {item_name}信息显示可能有问题")
                
                self.take_screenshot('view_order_info_displayed')
                
                # 检查是否有关闭按钮
                close_button_selectors = [
                    'button:has-text("关闭")',
                    'button:has-text("确定")',
                    'button:has-text("取消")',
                    '.el-dialog__close',
                    'button[aria-label="关闭"]'
                ]
                
                dialog_closed = False
                for selector in close_button_selectors:
                    if self.is_element_visible(selector):
                        print(f"找到关闭按钮: {selector}")
                        self.click_element(selector)
                        self.page.wait_for_timeout(2000)
                        
                        # 检查弹窗是否关闭
                        if not self.is_element_visible('.dialog-overlay'):
                            print("✅ 查看订单弹窗已关闭")
                            self.take_screenshot('view_order_dialog_closed')
                            dialog_closed = True
                            break
                        else:
                            print("⚠️ 弹窗未关闭，尝试其他关闭方式")
                
                if not dialog_closed:
                    # 尝试点击弹窗外部区域关闭
                    try:
                        self.page.click('.dialog-overlay', position={'x': 10, 'y': 10})
                        self.page.wait_for_timeout(2000)
                        if not self.is_element_visible('.dialog-overlay'):
                            print("✅ 通过点击外部区域关闭弹窗")
                            dialog_closed = True
                    except Exception as e:
                        print(f"点击外部区域关闭失败: {e}")
                
                if not dialog_closed:
                    print("⚠️ 无法关闭查看弹窗，但查看功能正常")
                
            else:
                print("❌ 查看订单弹窗未打开")
                self.take_screenshot('view_order_dialog_not_opened')
        else:
            print("❌ 未找到 TEST-ORDER-0001 订单或查看按钮")
            self.take_screenshot('view_button_not_found')
        
        print("查看订单功能测试通过")

def run_order_management_tests():
    """运行所有订单管理测试"""
    test = OrderManagementTest(headless=False, slow_mo=500)  # 非无头模式，慢速执行
    
    # 先设置浏览器并登录一次
    try:
        test.setup_browser()
        # 手动登录流程
        print("开始登录...")
        test.navigate_to(test.base_url)
        test.fill_input('input[placeholder="请输入用户名"]', 'admin')
        test.fill_input('input[placeholder="请输入密码"]', 'password')
        test.click_element('button:has-text("登录")')
        test.page.wait_for_timeout(5000)
        
        # 检查登录是否成功
        current_url = test.page.url
        if 'dashboard' in current_url:
            print("✅ 登录成功")
            login_success = True
        else:
            print(f"❌ 登录失败，当前URL: {current_url}")
            login_success = False
        
        if not login_success:
            print("❌ 登录失败，无法运行订单管理测试")
            return []
        
        # 导航到订单管理页面
        test.navigate_to(f'{test.base_url}/main/order')
        test.wait_for_element('.order-container', timeout=15000)
        print("✅ 成功进入订单管理页面")
        
        # 运行所有测试（不重新创建浏览器）
        tests = [
            ('订单列表显示测试', test.test_order_list_display),
            ('按订单编号搜索测试', test.test_order_search_by_order_no),
            ('按经销商搜索测试', test.test_order_search_by_dealer),
            ('订单状态筛选测试', test.test_order_status_filter),
            ('重置搜索测试', test.test_reset_search),
            ('分页功能测试', test.test_pagination),
            ('表格操作测试', test.test_table_operations),
            ('新增订单功能测试', test.test_add_order),
            ('编辑订单功能测试', test.test_edit_order),
            ('查看订单功能测试', test.test_view_order),
        ]
        
        results = []
        for test_name, test_func in tests:
            print(f"\n{'='*50}")
            print(f"开始测试: {test_name}")
            print(f"{'='*50}")
            
            start_time = datetime.now()
            result = {
                'test_name': test_name,
                'start_time': start_time.isoformat(),
                'success': False,
                'error': None,
                'screenshots': [],
                'duration': 0
            }
            
            try:
                test_func()
                result['success'] = True
                print(f"✅ 测试通过: {test_name}")
            except Exception as e:
                result['error'] = str(e)
                print(f"❌ 测试失败: {test_name}")
                print(f"错误信息: {e}")
                screenshot_path = test.take_screenshot(f'{test_name}_error')
                result['screenshots'].append(screenshot_path)
            finally:
                end_time = datetime.now()
                result['end_time'] = end_time.isoformat()
                result['duration'] = (end_time - start_time).total_seconds()
                print(f"测试耗时: {result['duration']:.2f}秒")
            
            results.append(result)
        
        return results
        
    finally:
        test.teardown_browser()
    
    # 打印测试总结
    print(f"\n{'='*60}")
    print("订单管理测试总结")
    print(f"{'='*60}")
    
    passed = sum(1 for r in results if r['success'])
    total = len(results)
    
    for result in results:
        status = "✅ 通过" if result['success'] else "❌ 失败"
        print(f"{result['test_name']}: {status} ({result['duration']:.2f}s)")
        if result['error']:
            print(f"  错误: {result['error']}")
    
    print(f"\n总计: {passed}/{total} 个测试通过")
    
    return results


if __name__ == '__main__':
    run_order_management_tests()