#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""
测试从文件加载 JSON Schema 功能

这个测试脚本验证系统能够正确地从文件系统加载 JSON Schema 定义，
并使用这些 Schema 进行数据验证。
"""

import sys
import os
import unittest
import json
import logging
from pathlib import Path

# 添加项目根目录到 Python 路径
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))

from ddms_compliance_suite.json_schema_validator.validator import JSONSchemaValidator
from ddms_compliance_suite.rule_repository.repository import RuleRepository
from ddms_compliance_suite.models.config_models import RuleRepositoryConfig
from ddms_compliance_suite.models.rule_models import TargetType

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

class TestLoadSchemaFromFile(unittest.TestCase):
    """测试从文件加载 JSON Schema 功能"""
    
    def setUp(self):
        """测试前的设置"""
        # 创建规则仓库配置
        config = RuleRepositoryConfig(
            storage={"type": "filesystem", "path": "./rules"},
            preload_rules=True
        )
        
        # 初始化规则仓库
        self.rule_repository = RuleRepository(config)
        
        # 创建 JSON Schema 验证器
        self.schema_validator = JSONSchemaValidator()
        
    def test_load_well_schema(self):
        """测试加载井数据 Schema"""
        # 从仓库加载 Schema
        well_schema = self.rule_repository.get_schema_for_target(
            TargetType.API_RESPONSE, "getWellData"
        )
        
        # 验证 Schema 是否已加载
        self.assertIsNotNone(well_schema, "无法加载井数据 Schema")
        self.assertIsInstance(well_schema, dict, "Schema 不是字典类型")
        self.assertIn("properties", well_schema, "Schema 缺少 properties 字段")
        
        # 验证 Schema 中的必要字段
        self.assertIn("wellName", well_schema["properties"], "Schema 缺少 wellName 字段")
        self.assertIn("wellID", well_schema["properties"], "Schema 缺少 wellID 字段")
        
        logger.info("成功加载井数据 Schema")
        
        # 测试使用加载的 Schema 验证数据
        valid_data = {
            "wellName": "测试井-01",
            "wellID": "W0123456789",
            "status": "active",
            "coordinates": {
                "longitude": 116.3833,
                "latitude": 39.9167
            }
        }
        
        result = self.schema_validator.validate(valid_data, well_schema)
        self.assertTrue(result.is_valid, f"验证失败: {result.errors}")
        
        # 测试无效数据
        invalid_data = {
            "wellName": "测试井-01",
            # 缺少 wellID
            "status": "active",
            "coordinates": {
                "longitude": 116.3833,
                "latitude": 39.9167
            }
        }
        
        result = self.schema_validator.validate(invalid_data, well_schema)
        self.assertFalse(result.is_valid, "验证应该失败但成功了")
        self.assertGreater(len(result.errors), 0, "应该有验证错误")
        
    def test_load_seismic_schema(self):
        """测试加载地震体数据 Schema"""
        # 从仓库加载 Schema
        seismic_schema = self.rule_repository.get_schema_for_target(
            TargetType.DATA_OBJECT, "Seismic"
        )
        
        # 验证 Schema 是否已加载
        self.assertIsNotNone(seismic_schema, "无法加载地震体数据 Schema")
        self.assertIsInstance(seismic_schema, dict, "Schema 不是字典类型")
        self.assertIn("properties", seismic_schema, "Schema 缺少 properties 字段")
        
        # 验证 Schema 中的必要字段
        self.assertIn("projectId", seismic_schema["properties"], "Schema 缺少 projectId 字段")
        self.assertIn("dimensions", seismic_schema["properties"], "Schema 缺少 dimensions 字段")
        
        logger.info("成功加载地震体数据 Schema")
        
        # 测试使用加载的 Schema 验证数据
        valid_data = {
            "projectId": "testPrj1",
            "surveyId": "20230117135924_2",
            "seismicName": "西部地震体-01",
            "dsType": 1,
            "dimensions": [
                {
                    "dimensionNo": 1,
                    "dimensionName": "inline",
                    "serviceMin": 100,
                    "serviceMax": 500,
                    "serviceSpan": 1
                }
            ]
        }
        
        result = self.schema_validator.validate(valid_data, seismic_schema)
        self.assertTrue(result.is_valid, f"验证失败: {result.errors}")
        
        # 测试无效数据 - 缺少必要字段
        invalid_data = {
            "projectId": "testPrj1",
            # 缺少 surveyId
            "seismicName": "西部地震体-01",
            "dsType": 1
            # 缺少 dimensions
        }
        
        result = self.schema_validator.validate(invalid_data, seismic_schema)
        self.assertFalse(result.is_valid, "验证应该失败但成功了")
        self.assertGreater(len(result.errors), 0, "应该有验证错误")
        
        # 测试属性体无效数据 - 缺少 baseSeismicId
        invalid_attribute_data = {
            "projectId": "testPrj1",
            "surveyId": "20230117135924_2",
            "seismicName": "属性体",
            "dsType": 2,  # 属性体类型
            "dimensions": [
                {
                    "dimensionNo": 1,
                    "dimensionName": "inline",
                    "serviceMin": 100,
                    "serviceMax": 500,
                    "serviceSpan": 1
                }
            ]
            # 缺少 baseSeismicId
        }
        
        result = self.schema_validator.validate(invalid_attribute_data, seismic_schema)
        self.assertFalse(result.is_valid, "属性体验证应该失败但成功了")
        self.assertGreater(len(result.errors), 0, "应该有验证错误")
        
    def test_load_api_response_schema(self):
        """测试加载 API 响应 Schema"""
        # 从仓库加载 Schema
        api_schema = self.rule_repository.get_schema_for_target(
            TargetType.API_RESPONSE, "SeismicAPIResponse"
        )
        
        # 验证 Schema 是否已加载
        self.assertIsNotNone(api_schema, "无法加载 API 响应 Schema")
        self.assertIsInstance(api_schema, dict, "Schema 不是字典类型")
        self.assertIn("properties", api_schema, "Schema 缺少 properties 字段")
        
        # 验证 Schema 中的必要字段
        self.assertIn("code", api_schema["properties"], "Schema 缺少 code 字段")
        self.assertIn("flag", api_schema["properties"], "Schema 缺少 flag 字段")
        self.assertIn("msg", api_schema["properties"], "Schema 缺少 msg 字段")
        
        logger.info("成功加载 API 响应 Schema")
        
        # 测试使用加载的 Schema 验证数据
        valid_data = {
            "code": "0",
            "flag": True,
            "msg": "操作成功",
            "result": "20230601123456_1"
        }
        
        result = self.schema_validator.validate(valid_data, api_schema)
        self.assertTrue(result.is_valid, f"验证失败: {result.errors}")
        
        # 测试无效数据
        invalid_data = {
            "code": "0",
            "flag": True,
            # 缺少 msg
            "result": "20230601123456_1"
        }
        
        result = self.schema_validator.validate(invalid_data, api_schema)
        self.assertFalse(result.is_valid, "验证应该失败但成功了")
        self.assertGreater(len(result.errors), 0, "应该有验证错误")

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