import asyncio
from anthropic import Anthropic
from computer_use import ComputerUse

class FormFillingBot:
    """
    自动填表机器人
    
    为什么需要这个类？
    封装常见操作，提供高级API
    """
    
    def __init__(self, consent_level: str = "read_write"):
        self.client = Anthropic()
        self.computer = ComputerUse(consent_level=consent_level)
        self.task_history = []  # 记录操作历史
    
    async def fill_form(self, form_url: str, form_data: dict):
        """
        填写表单的主要流程
        
        为什么分步骤？
        1. 便于调试 - 出问题能快速定位
        2. 便于重试 - 失败的操作可以单独重试
        3. 便于日志 - 详细记录每一步
        """
        try:
            # 步骤1：打开表单页面
            await self._navigate_to_form(form_url)
            
            # 步骤2：分析表单结构
            form_structure = await self._analyze_form()
            
            # 步骤3：逐个填写字段
            for field_name, value in form_data.items():
                await self._fill_field(field_name, value)
            
            # 步骤4：提交表单
            await self._submit_form()
            
            return {"success": True, "steps_completed": len(self.task_history)}
        
        except Exception as e:
            return {
                "success": False,
                "error": str(e),
                "steps_completed": self.task_history
            }
    
    async def _navigate_to_form(self, url: str):
        """导航到表单页面"""
        # 1. 先截一张图确认当前位置
        screenshot = await self.computer.screenshot()
        
        # 2. 打开新标签页（Ctrl+T）
        await self.computer.keyboard.press("ctrl+t")
        
        # 3. 输入URL
        await self.computer.keyboard.type(url)
        
        # 4. 按回车
        await self.computer.keyboard.press("enter")
        
        # 5. 等待页面加载
        await asyncio.sleep(2)
        
        # 6. 再次截图确认页面已加载
        await self.computer.screenshot()
        
        self.task_history.append({
            "step": "navigate",
            "url": url
        })
    
    async def _analyze_form(self) -> dict:
        """分析表单结构"""
        # 截取当前屏幕
        screenshot = await self.computer.screenshot()
        
        # 让Claude分析截图中的表单字段
        analysis_prompt = """
        请分析这个截图中的表单结构。
        返回JSON格式，包含：
        - fields: 字段列表，每个字段包含name、type、position
        - submit_button: 提交按钮的位置
        """
        
        response = self.client.messages.create(
            model="claude-opus-4-20241120",
            max_tokens=1024,
            messages=[{
                "role": "user",
                "content": [
                    {"type": "image", "source": screenshot},
                    {"type": "text", "text": analysis_prompt}
                ]
            }]
        )
        
        return self._parse_form_analysis(response.content[0].text)
    
    async def _fill_field(self, field_name: str, value: str):
        """填写单个字段"""
        # 1. 点击字段位置
        # （实际实现中需要根据_analyze_form的结果确定位置）
        await self.computer.mouse.click(x=field_name["x"], y=field_name["y"])
        
        # 2. 输入内容
        await self.computer.keyboard.type(value)
        
        # 3. 按Tab跳到下一个字段
        await self.computer.keyboard.press("tab")
        
        self.task_history.append({
            "step": "fill_field",
            "field": field_name,
            "value": value
        })
    
    async def _submit_form(self):
        """提交表单"""
        # 点击提交按钮
        # （实际实现中需要根据_analyze_form的结果确定位置）
        await self.computer.mouse.click(x="submit_x", y="submit_y")
        
        # 等待提交完成
        await asyncio.sleep(3)
        
        # 截图确认提交结果
        result_screenshot = await self.computer.screenshot()
        
        self.task_history.append({
            "step": "submit",
            "screenshot": result_screenshot
        })

class TestingAssistant:
    """
    自动化测试助手
    
    使用Computer Use执行UI测试
    """
    
    def __init__(self, app_url: str):
        self.app_url = app_url
        self.computer = ComputerUse()
        self.test_results = []
    
    async def run_ui_test(self, test_case: dict) -> dict:
        """
        执行UI测试
        
        测试流程：
        1. 打开应用
        2. 执行测试操作
        3. 验证结果
        4. 记录测试报告
        """
        test_id = test_case["id"]
        steps = test_case["steps"]
        expected = test_case["expected"]
        
        try:
            # 打开应用
            await self._open_application()
            
            # 执行测试步骤
            for step in steps:
                await self._execute_step(step)
            
            # 验证结果
            actual = await self._capture_result()
            
            # 比对结果
            passed = self._compare_results(expected, actual)
            
            result = {
                "test_id": test_id,
                "status": "passed" if passed else "failed",
                "expected": expected,
                "actual": actual,
                "screenshots": self.test_results
            }
            
            self.test_results.append(result)
            return result
        
        except Exception as e:
            return {
                "test_id": test_id,
                "status": "error",
                "error": str(e)
            }
    
    async def _open_application(self):
        """打开测试应用"""
        await self.computer.browser.open(self.app_url)
        await asyncio.sleep(2)  # 等待页面加载
    
    async def _execute_step(self, step: dict):
        """执行单个测试步骤"""
        action = step["action"]
        
        if action == "click":
            await self.computer.mouse.click(x=step["x"], y=step["y"])
        elif action == "type":
            await self.computer.keyboard.type(step["text"])
        elif action == "select":
            await self.computer.mouse.click(x=step["x"], y=step["y"])
            await self.computer.keyboard.press("down")
            await self.computer.keyboard.press("enter")
        
        await asyncio.sleep(step.get("delay", 1))
        
        # 每步都截图记录
        await self.computer.screenshot()
    
    async def _capture_result(self) -> dict:
        """捕获测试结果"""
        screenshot = await self.computer.screenshot()
        
        # 让Claude分析截图中的关键信息
        return {"screenshot": screenshot}
    
    def _compare_results(self, expected: dict, actual: dict) -> bool:
        """比对测试结果"""
        # 实际实现中需要根据具体测试类型比对
        return True