
"""
最终估值A计算模块
最终估值A = 模型估值B × 0.7 + 市场估值C × 0.3

"""

from typing import Dict
import os
import sys
import asyncio
from app.log.log import logger
current_dir = os.path.dirname(os.path.abspath(__file__))
project_root = os.path.abspath(os.path.join(current_dir, os.pardir, os.pardir, os.pardir, os.pardir))
if project_root not in sys.path:
    sys.path.append(project_root)

try:
    # 包内相对导入
    from .model_value_b import ModelValueBCalculator
    from ..market_value_c import MarketValueCCalculator
except ImportError:
    # 直接运行时的绝对导入
    from app.utils.calculation_engine.final_value_ab.model_value_b import ModelValueBCalculator
    from app.utils.calculation_engine.market_value_c import MarketValueCCalculator


class FinalValueACalculator:
    """最终估值A计算器"""
    
    def __init__(self):
        """初始化计算器"""
        self.model_value_calculator = ModelValueBCalculator()
        self.market_value_calculator = MarketValueCCalculator()
    
    def calculate_final_value_a(self,
                               model_value_b: float,
                               market_value_c: float) -> float:
        """
        计算最终估值A
        
        
        最终估值A = 模型估值B × 0.7 + 市场估值C × 0.3

        model_value_b: 模型估值B (系统计算)
        market_value_c: 市场估值C (系统计算)

        float: 最终估值A
        """
        logger.info("final_value_a.calculate_final_value_a 开始计算最终估值A: 模型估值B={}万元 市场估值C={}万元", 
                   model_value_b, market_value_c)
        
        # 计算加权值
        model_weighted = model_value_b * 0.7
        market_weighted = market_value_c * 0.3
        
        logger.info("final_value_a.weighted_values 加权计算: 模型估值B加权值={}万元(权重0.7) 市场估值C加权值={}万元(权重0.3)", 
                   model_weighted, market_weighted)
        
        final_value = model_weighted + market_weighted
        
        logger.info("final_value_a.final_calculation 最终估值A计算: 模型估值B={}万元 市场估值C={}万元 模型加权值={}万元 市场加权值={}万元 最终估值AB={}万元", 
                   model_value_b, market_value_c, model_weighted, market_weighted, final_value)
        
        return final_value
    
    async def calculate_complete_final_value_a(self, input_data: Dict) -> Dict:
        """
        计算完整的最终估值A，包含所有子模块

        input_data: 输入数据字典，包含所有必要的参数
            

        包含所有中间计算结果和最终结果的字典
        """
        import time
        start_time = time.time()
        
        # 记录输入参数
        logger.info("final_value_a.calculation_start input_data_keys={} model_data_keys={} market_data_keys={}", 
                   list(input_data.keys()),
                   list(input_data.get('model_data', {}).keys()),
                   list(input_data.get('market_data', {}).keys()))
        
        # 详细记录模型数据参数
        model_data = input_data.get('model_data', {})
        if 'economic_data' in model_data:
            economic_data = model_data['economic_data']
            logger.info("final_value_a.economic_data 经济价值B1参数: 近三年机构收益={} 专利分={} 普及地域分={} 侵权分={} 创新投入比={} ESG分={} 专利使用量={} 行业修正系数={}",
                       economic_data.get('three_year_income'),
                       economic_data.get('patent_score'),
                       economic_data.get('popularity_score'),
                       economic_data.get('infringement_score'),
                       economic_data.get('innovation_ratio'),
                       economic_data.get('esg_score'),
                       economic_data.get('patent_count'),
                       economic_data.get('industry_coefficient'))
        
        if 'cultural_data' in model_data:
            cultural_data = model_data['cultural_data']
            logger.info("final_value_a.cultural_data 文化价值B2参数: 传承人等级系数={} 跨境深度={} 线下教学次数={} 抖音浏览量={} 快手浏览量={} 哔哩哔哩浏览量={} 结构复杂度={} 归一化信息熵={} 历史传承度={}",
                       cultural_data.get('inheritor_level_coefficient'),
                       cultural_data.get('cross_border_depth'),
                       cultural_data.get('offline_sessions'),
                       cultural_data.get('douyin_views'),
                       cultural_data.get('kuaishou_views'),
                       cultural_data.get('bilibili_views'),
                       cultural_data.get('structure_complexity'),
                       cultural_data.get('normalized_entropy'),
                       cultural_data.get('historical_inheritance'))
        
        if 'risky_data' in model_data:
            risky_data = model_data['risky_data']
            logger.info("final_value_a.risky_data 风险调整B3参数: 最高价={} 最低价={} 诉讼状态={} 传承人年龄={}",
                       risky_data.get('highest_price'),
                       risky_data.get('lowest_price'),
                       risky_data.get('lawsuit_status'),
                       risky_data.get('inheritor_ages'))
        
        # 详细记录市场数据参数
        market_data = input_data.get('market_data', {})
        logger.info("final_value_a.market_data 市场估值C参数: 平均交易价={} 手动出价={} 专家估值={} 日浏览量={} 收藏数量={} 发行等级={} 最近市场活动={}",
                   market_data.get('average_transaction_price'),
                   market_data.get('manual_bids'),
                   market_data.get('expert_valuations'),
                   market_data.get('daily_browse_volume'),
                   market_data.get('collection_count'),
                   market_data.get('issuance_level'),
                   market_data.get('recent_market_activity'))
        
        # 计算模型估值B
        logger.info("final_value_a.calculating_model_value_b 开始计算模型估值B")
        model_start_time = time.time()
        
        try:
            model_result = self.model_value_calculator.calculate_complete_model_value_b(
                input_data['model_data']
            )
            model_value_b = model_result['model_value_b']
            model_duration = time.time() - model_start_time
            
            logger.info("final_value_a.model_value_b_calculated 模型估值B计算完成: 模型估值B={}万元 耗时={}ms 返回字段={}", 
                       model_value_b, 
                       int(model_duration * 1000),
                       list(model_result.keys()))
            
        except Exception as e:
            logger.error("final_value_a.model_value_b_calculation_failed 模型估值B计算失败: 错误={} 输入数据={}", str(e), input_data.get('model_data', {}))
            raise
        
        # 计算市场估值C
        logger.info("final_value_a.calculating_market_value_c 开始计算市场估值C")
        market_start_time = time.time()
        
        try:
            market_result = await self.market_value_calculator.calculate_complete_market_value_c(
                input_data['market_data']
            )
            market_value_c = market_result['market_value_c']
            market_duration = time.time() - market_start_time
            
            logger.info("final_value_a.market_value_c_calculated 市场估值C计算完成: 市场估值C={}万元 耗时={}ms 返回字段={}", 
                       market_value_c, 
                       int(market_duration * 1000),
                       list(market_result.keys()))
            
        except Exception as e:
            logger.error("final_value_a.market_value_c_calculation_failed 市场估值C计算失败: 错误={} 输入数据={}", str(e), input_data.get('market_data', {}))
            raise
        
        # 计算最终估值A
        logger.info("final_value_a.calculating_final_value_a 开始计算最终估值A: 模型估值B={}万元 市场估值C={}万元", 
                   model_value_b, market_value_c)
        
        try:
            final_value_a = self.calculate_final_value_a(
                model_value_b,
                market_value_c
            )
            
            # 记录最终计算结果
            total_duration = time.time() - start_time
            logger.info("final_value_a.calculation_completed 最终估值A计算完成: 最终估值AB={}万元 模型估值B={}万元 市场估值C={}万元 总耗时={}ms 模型计算耗时={}ms 市场计算耗时={}ms", 
                       final_value_a,
                       model_value_b,
                       market_value_c,
                       int(total_duration * 1000),
                       int(model_duration * 1000),
                       int(market_duration * 1000))
            
        except Exception as e:
            logger.error("final_value_a.final_value_calculation_failed 最终估值A计算失败: 错误={} 模型估值B={}万元 市场估值C={}万元", 
                        str(e), model_value_b, market_value_c)
            raise
        
        return {
            'model_value_b': model_value_b,
            'market_value_c': market_value_c,
            'final_value_ab': final_value_a,
        }
    


# 示例使用
if __name__ == "__main__":
    # 创建计算器实例
    calculator = FinalValueACalculator()
    
    # 示例数据
    input_data = {
        # 模型估值B相关数据
        'model_data': {
            'economic_data': {
                # 基础价值B11相关参数
                'three_year_income': [2000,2400,2600],
                'patent_score': 1,  # 专利分 (0-10)
                'popularity_score': 4.0,  # 普及地域分 (0-10)
                'infringement_score': 1.0,  # 侵权分 (0-10)
                'innovation_ratio': 600.0,  # 创新投入比 (×100)
                'esg_score': 10.0,  # ESG分 (0-10)
                'patent_count':0.8,
                'industry_coefficient': 12.0,

                # 流量因子B12相关参数
                'search_index_s1': 4500.0,
                'industry_average_s2': 5000.0,
                'likes': 4,
                'comments': 5,
                'shares': 6,

                # 政策乘数B13相关参数
                'policy_match_score': 10.0,
                'implementation_stage': 10.0,
                'funding_support': 10.0
            },
            'cultural_data': {
                # 活态传承系数B21相关参数（教学频次由以下数据计算）
                'inheritor_level_coefficient': 10.0,
                'cross_border_depth': 7.0,
                'offline_sessions': 1,
                'douyin_views': 2,
                'kuaishou_views': 3,
                'bilibili_views': 4,

                # 纹样基因值B22相关参数
                'structure_complexity': 0.75,
                'normalized_entropy': 0.85,
                'historical_inheritance': 0.80
            },
            'risky_data': {
                # 风险调整系数B3相关参数
                'highest_price': 100.0,
                'lowest_price': 95.0,
                'lawsuit_status': '无诉讼',
                'inheritor_ages': [45, 60, 75]
            }
        },
        
        # 市场估值C相关数据
        'market_data': {
            'average_transaction_price': 50000.0,
            'manual_bids': [48000.0, 50000.0, 52000.0],
            'expert_valuations': [49000.0, 51000.0, 50000.0],
            'daily_browse_volume': 500.0,
            'collection_count': 50,
            'issuance_level': '限量',
            'recent_market_activity': '近一月'
        }
    }
    
    # 计算最终估值A
    async def main():
        result = await calculator.calculate_complete_final_value_a(input_data)
        
        print("最终估值A计算结果:")
        print(f"模型估值B: {result['model_value_b']:.2f}")
        print(f"市场估值C: {result['market_value_c']:.2f}")
        print(f"最终估值A: {result['final_value_ab']:.2f}")
    
    asyncio.run(main())


