"""
数据模型测试用例
"""

import unittest
import tempfile
import os
from datetime import datetime, timedelta
from app import create_app, db
from app.models import Admin, Product, License, Device

class TestModels(unittest.TestCase):
    """数据模型测试"""

    def setUp(self):
        """测试前准备"""
        self.app = create_app('testing')
        self.app_context = self.app.app_context()
        self.app_context.push()

        # 使用内存数据库
        self.app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'
        db.create_all()

    def tearDown(self):
        """测试后清理"""
        db.session.remove()
        db.drop_all()
        self.app_context.pop()

    def test_admin_model(self):
        """测试管理员模型"""
        # 创建管理员
        admin = Admin(
            username='testadmin',
            email='test@example.com',
            role=1
        )
        admin.set_password('testpass123')
        db.session.add(admin)
        db.session.commit()

        # 验证密码
        self.assertTrue(admin.verify_password('testpass123'))
        self.assertFalse(admin.verify_password('wrongpass'))

        # 验证权限
        self.assertTrue(admin.is_super_admin())
        self.assertTrue(admin.is_active())

    def test_product_model(self):
        """测试产品模型"""
        # 创建产品
        product = Product(
            product_id='TEST_PRODUCT',
            product_name='测试产品',
            description='这是一个测试产品'
        )
        db.session.add(product)
        db.session.commit()

        # 验证产品
        self.assertEqual(product.product_id, 'TEST_PRODUCT')
        self.assertEqual(product.product_name, '测试产品')
        self.assertTrue(product.is_enabled())

        # 测试统计信息
        stats = product.get_stats()
        self.assertEqual(stats['total_licenses'], 0)
        self.assertEqual(stats['active_licenses'], 0)
        self.assertEqual(stats['total_devices'], 0)

    def test_license_model(self):
        """测试卡密模型"""
        # 先创建产品
        product = Product(
            product_id='TEST_PRODUCT',
            product_name='测试产品'
        )
        db.session.add(product)
        db.session.commit()

        # 创建卡密
        license_obj = License(
            product_id='TEST_PRODUCT',
            type=1,
            valid_days=30,
            status=0
        )
        db.session.add(license_obj)
        db.session.commit()

        # 验证卡密
        self.assertIsNotNone(license_obj.license_key)
        self.assertEqual(len(license_obj.license_key), 32)
        self.assertTrue(license_obj.is_formal())
        self.assertFalse(license_obj.is_trial())
        self.assertTrue(license_obj.can_activate())
        self.assertFalse(license_obj.is_expired())

        # 测试激活
        success, message = license_obj.activate('TEST_MACHINE_CODE', '1.0.0')
        self.assertTrue(success)
        self.assertEqual(message, '激活成功')
        self.assertTrue(license_obj.is_active())

        # 测试验证
        success, message = license_obj.verify('TEST_MACHINE_CODE', '1.0.0')
        self.assertTrue(success)
        self.assertEqual(message, '验证通过')

        # 测试设备不匹配
        success, message = license_obj.verify('WRONG_MACHINE_CODE', '1.0.0')
        self.assertFalse(success)
        self.assertEqual(message, '设备不匹配')

    def test_device_model(self):
        """测试设备模型"""
        # 创建产品
        product = Product(product_id='TEST_PRODUCT', product_name='测试产品')
        db.session.add(product)

        # 创建卡密
        license_obj = License(
            product_id='TEST_PRODUCT',
            type=1,
            valid_days=30
        )
        db.session.add(license_obj)
        db.session.commit()

        # 创建设备
        device = Device(
            machine_code='TEST_MACHINE_CODE',
            license_id=license_obj.license_id,
            product_id='TEST_PRODUCT',
            software_version='1.0.0'
        )
        db.session.add(device)
        db.session.commit()

        # 验证设备
        self.assertTrue(device.is_active())
        self.assertTrue(device.is_online())

        # 测试使用时间
        uptime_days = device.get_uptime_days()
        self.assertGreaterEqual(uptime_days, 0)

    def test_license_batch_generation(self):
        """测试批量生成卡密"""
        # 创建产品
        product = Product(product_id='TEST_PRODUCT', product_name='测试产品')
        db.session.add(product)
        db.session.commit()

        # 批量生成卡密
        licenses = License.generate_batch(
            product_id='TEST_PRODUCT',
            count=5,
            license_type=1,
            valid_days=365
        )

        self.assertEqual(len(licenses), 5)

        # 保存到数据库
        db.session.add_all(licenses)
        db.session.commit()

        # 验证生成的卡密
        for license_obj in licenses:
            self.assertEqual(license_obj.product_id, 'TEST_PRODUCT')
            self.assertEqual(license_obj.type, 1)
            self.assertEqual(license_obj.valid_days, 365)
            self.assertEqual(license_obj.status, 0)
            self.assertIsNotNone(license_obj.license_key)
            self.assertEqual(len(license_obj.license_key), 32)

    def test_license_extension(self):
        """测试卡密延期"""
        # 创建产品和卡密
        product = Product(product_id='TEST_PRODUCT', product_name='测试产品')
        db.session.add(product)

        license_obj = License(
            product_id='TEST_PRODUCT',
            type=1,
            valid_days=30,
            status=1,
            activate_time=datetime.utcnow()
        )
        db.session.add(license_obj)
        db.session.commit()

        original_expire_time = license_obj.expire_time

        # 延期30天
        success, message = license_obj.extend_validity(30)
        self.assertTrue(success)
        self.assertEqual(message, '延期成功')

        # 验证延期后的时间
        expected_expire_time = original_expire_time + timedelta(days=30)
        self.assertEqual(license_obj.expire_time, expected_expire_time)

    def test_trial_conversion(self):
        """测试试用转正式"""
        # 创建产品和试用卡密
        product = Product(product_id='TEST_PRODUCT', product_name='测试产品')
        db.session.add(product)

        license_obj = License(
            product_id='TEST_PRODUCT',
            type=0,  # 试用
            valid_days=7,
            status=1,
            activate_time=datetime.utcnow()
        )
        db.session.add(license_obj)
        db.session.commit()

        # 转为正式
        success, message = license_obj.convert_to_formal(365)
        self.assertTrue(success)
        self.assertEqual(message, '转换成功')

        # 验证转换结果
        self.assertTrue(license_obj.is_formal())
        self.assertFalse(license_obj.is_trial())
        self.assertEqual(license_obj.valid_days, 365)

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