import unittest
from unittest.mock import patch, MagicMock
import sys
import os

# 添加项目根目录到Python路径
sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))

from hardware.transmitter import TransmitterController
from pymodbus.exceptions import ModbusException


class TestTransmitterController(unittest.TestCase):

    def setUp(self):
        """测试前的准备工作"""
        # 创建模拟的继电器控制器
        self.mock_relay = MagicMock()
        self.mock_relay.modbus_client = MagicMock()
        
        # 创建变送器控制器实例
        self.transmitter = TransmitterController(relay_controller=self.mock_relay)

    def test_transmitter_initialization(self):
        """测试变送器控制器初始化"""
        self.assertEqual(self.transmitter.relay_controller, self.mock_relay)
        
        # 检查配置
        self.assertIn(1, self.transmitter.config)  # 上料斗
        self.assertIn(2, self.transmitter.config)  # 下料斗
        
        # 检查上料斗配置
        upper_config = self.transmitter.config[1]
        self.assertEqual(upper_config['slave_id'], 1)
        self.assertEqual(upper_config['weight_register'], 0x01)
        self.assertEqual(upper_config['register_count'], 2)
        
        # 检查下料斗配置
        lower_config = self.transmitter.config[2]
        self.assertEqual(lower_config['slave_id'], 2)
        self.assertEqual(lower_config['weight_register'], 0x01)
        self.assertEqual(lower_config['register_count'], 2)

    def test_read_data_valid_transmitter_id(self):
        """测试读取有效变送器ID的数据"""
        # 配置模拟对象
        self.mock_relay.modbus_client.connect.return_value = True
        
        # 模拟读取结果
        mock_result = MagicMock()
        mock_result.registers = [0, 1500]  # 表示1500kg
        self.mock_relay.modbus_client.read_holding_registers.return_value = mock_result
        
        # 读取上料斗数据
        weight = self.transmitter.read_data(1)
        
        # 验证调用
        self.mock_relay.modbus_client.connect.assert_called_once()
        self.mock_relay.modbus_client.read_holding_registers.assert_called_once()
        self.assertEqual(weight, 1.5)  # 1500kg / 1000 = 1.5kg

    def test_read_data_invalid_transmitter_id(self):
        """测试读取无效变送器ID的数据"""
        # 读取无效ID的数据
        weight = self.transmitter.read_data(99)
        
        # 验证结果
        self.assertIsNone(weight)
        self.mock_relay.modbus_client.connect.assert_not_called()
        self.mock_relay.modbus_client.read_holding_registers.assert_not_called()

    def test_read_data_connection_failed(self):
        """测试读取数据时连接失败"""
        # 配置模拟对象
        self.mock_relay.modbus_client.connect.return_value = False
        
        # 读取数据
        weight = self.transmitter.read_data(1)
        
        # 验证结果
        self.assertIsNone(weight)
        self.mock_relay.modbus_client.connect.assert_called_once()
        self.mock_relay.modbus_client.read_holding_registers.assert_not_called()

    def test_read_data_modbus_exception(self):
        """测试读取数据时Modbus异常"""
        # 配置模拟对象
        self.mock_relay.modbus_client.connect.return_value = True
        self.mock_relay.modbus_client.read_holding_registers.side_effect = ModbusException("Modbus错误")
        
        # 读取数据
        weight = self.transmitter.read_data(1)
        
        # 验证结果
        self.assertIsNone(weight)

    def test_read_data_register_count_2(self):
        """测试读取2个寄存器的数据"""
        # 配置模拟对象
        self.mock_relay.modbus_client.connect.return_value = True
        
        # 模拟读取结果 (高位寄存器=1，低位寄存器=0xE848，表示128000)
        mock_result = MagicMock()
        mock_result.registers = [1, 0xE848]  # 1 * 65536 + 59464 = 125000
        self.mock_relay.modbus_client.read_holding_registers.return_value = mock_result
        
        # 读取数据
        weight = self.transmitter.read_data(1)
        
        # 验证结果 (125000 / 1000 = 125kg)
        self.assertEqual(weight, 125.0)

    def test_read_data_register_count_1(self):
        """测试读取1个寄存器的数据（模拟配置变更）"""
        # 临时修改配置以测试单寄存器读取
        self.transmitter.config[1]['register_count'] = 1
        
        # 配置模拟对象
        self.mock_relay.modbus_client.connect.return_value = True
        
        # 模拟读取结果
        mock_result = MagicMock()
        mock_result.registers = [1500]  # 表示1500kg
        self.mock_relay.modbus_client.read_holding_registers.return_value = mock_result
        
        # 读取数据
        weight = self.transmitter.read_data(1)
        
        # 验证结果
        self.assertEqual(weight, 1500.0)  # 1500kg

    def test_read_data_invalid_register_count(self):
        """测试不支持的寄存器数量"""
        # 临时修改配置以测试无效寄存器数量
        self.transmitter.config[1]['register_count'] = 3
        
        # 配置模拟对象
        self.mock_relay.modbus_client.connect.return_value = True
        
        # 模拟读取结果
        mock_result = MagicMock()
        mock_result.registers = [0, 0, 0]
        self.mock_relay.modbus_client.read_holding_registers.return_value = mock_result
        
        # 读取数据
        weight = self.transmitter.read_data(1)
        
        # 验证结果
        self.assertIsNone(weight)

    def test_read_data_result_is_exception(self):
        """测试读取结果为异常对象"""
        # 配置模拟对象
        self.mock_relay.modbus_client.connect.return_value = True
        self.mock_relay.modbus_client.read_holding_registers.return_value = Exception("读取错误")
        
        # 读取数据
        weight = self.transmitter.read_data(1)
        
        # 验证结果
        self.assertIsNone(weight)


if __name__ == '__main__':
    unittest.main()