import math
from typing import List, Optional


class BasicValueB11Calculator:
    """基础价值B11计算器"""

    def __init__(self):
        """初始化计算器"""
        pass

    def calculate_basic_value_b11(self,
                                  financial_value: float,
                                  legal_strength: float,
                                  development_potential: float,
                                  industry_coefficient: float) -> float:
        """
        计算基础价值B11

        基础价值B11 = 财务价值F × (0.45 + 0.05 × 行业系数I) + 法律强度L × (0.35 + 0.05 × 行业系数I) + 发展潜力D × 0.2

        args:
            financial_value: 财务价值F (用户填写)
            legal_strength: 法律强度L (用户填写)
            development_potential: 发展潜力D (用户填写)
            industry_coefficient: 行业系数I (系统配置)

        returns:
            float: 基础价值B11
        """
        basic_value = (financial_value * (0.45 + 0.05 * industry_coefficient) +
                       legal_strength * (0.35 + 0.05 * industry_coefficient) +
                       development_potential * 0.2)

        return basic_value

    def growth_rate(self, annual_revenue_3_years: List[float]):
        """

        """
        g1, g2 = (annual_revenue_3_years[1] - annual_revenue_3_years[0]) / annual_revenue_3_years[0] * 100, (
                    annual_revenue_3_years[2] - annual_revenue_3_years[1]) / annual_revenue_3_years[1] * 100
        predicted_growth = g2 + (g2 - g1)
        return predicted_growth

    def calculate_financial_value_f(self,
                                    annual_revenue_3_years: List[float],
                                    growth_rate: Optional[float] = None) -> float:
        """
        计算财务价值F

        财务价值F = [3年内年均收益 × (1 + 增长率)^5] / 5

        args:
            annual_revenue_3_years: 近三年年均收益列表，单位：万元 (用户填写)
            growth_rate: 增长率，如果为None则自动计算 (用户填写)

        returns:
            float: 财务价值F
        """
        if len(annual_revenue_3_years) != 3:
            raise ValueError("必须提供近三年的收益数据")

        # 计算年均收益
        avg_annual_revenue = sum(annual_revenue_3_years) / 3

        # 如果没有提供增长率，则根据三年数据计算
        if growth_rate is None:
            growth_rate = self._calculate_growth_rate(annual_revenue_3_years)

        financial_value = (avg_annual_revenue * math.pow(1 + growth_rate, 5)) / 5

        return financial_value

    def _calculate_growth_rate(self, revenue_data: List[float]) -> float:
        """
        根据三年收益数据计算增长率

        args:
            revenue_data: 三年收益数据 (用户填写)

        returns:
            float: 增长率
        """
        if len(revenue_data) != 3:
            raise ValueError("必须提供三年的收益数据")

        # 计算两个增长率差值作为预测的增长率差值
        growth_rate_1 = (revenue_data[1] - revenue_data[0]) / revenue_data[0] if revenue_data[0] != 0 else 0
        growth_rate_2 = (revenue_data[2] - revenue_data[1]) / revenue_data[1] if revenue_data[1] != 0 else 0

        # 使用两个增长率的平均值
        avg_growth_rate = (growth_rate_1 + growth_rate_2) / 2

        return avg_growth_rate

    def calculate_legal_strength_l(self,
                                   patent_score: float,
                                   popularity_score: float,
                                   infringement_score: float) -> float:
        """
        计算法律强度L


        法律强度L = 专利分 × 0.4 + 普及分 × 0.3 + 侵权分 × 0.3

        args:
            patent_score: 专利分 (0-10分) (用户填写)
            popularity_score: 普及地域分 (0-10分) (用户填写)
            infringement_score: 侵权分 (0-10分) (用户填写)

        returns:
            float: 法律强度L
        """

        legal_strength = (patent_score * 0.4 +
                          popularity_score * 0.3 +
                          infringement_score * 0.3)

        return legal_strength

    def calculate_development_potential_d(self,
                                          patent_score: float,
                                          esg_score: float,
                                          innovation_ratio: float) -> float:
        """
        计算发展潜力D


        发展潜力D = 专利分 × 0.5 + ESG分 × 0.2 + 创新投入比 × 0.3

        args:
            patent_score: 专利分 (0-10分) (用户填写)
            esg_score: ESG分 (0-10分) (用户填写)
            innovation_ratio: 创新投入比 (研发费用/营收) * 100 (用户填写)

        returns:
            float: 发展潜力D
        """

        development_potential = (patent_score * 0.5 +
                                 esg_score * 0.2 +
                                 innovation_ratio * 0.3)

        return development_potential

    def calculate_industry_coefficient_i(self,
                                         target_industry_roe: float,
                                         benchmark_industry_roe: float) -> float:
        """
        计算行业系数I

        行业系数I = (目标行业平均ROE - 基准行业ROE) / 基准行业ROE

        args:
            target_industry_roe: 目标行业平均ROE (系统配置)
            benchmark_industry_roe: 基准行业ROE (系统配置)

        returns:
            float: 行业系数I
        """
        if benchmark_industry_roe == 0:
            raise ValueError("基准行业ROE不能为0")

        industry_coefficient = (target_industry_roe - benchmark_industry_roe) / benchmark_industry_roe

        return industry_coefficient


# 专利相关计算函数
def calculate_patent_score(patent_remaining_years: int) -> float:
    """
    计算专利分

    专利剩余保护期评分标准：
    - >10年: 10分
    - 5-10年: 7分
    - <5年: 3分

    args:
        patent_remaining_years: 专利剩余保护期（年） (用户填写)

    returns:
        float: 专利分
    """
    if patent_remaining_years > 10:
        return 10.0
    elif patent_remaining_years >= 5:
        return 7.0
    else:
        return 3.0


# 识别用户所上传的图像中的专利号，通过API验证专利是否存在，按所用专利数量赋分，未引用0分，每引用一项+2.5分，10分封顶（0-10分）
def calculate_patent_usage_score(patent_count: int) -> float:
    """
    计算专利使用量分

    专利使用量评分标准：
    - 未引用: 0分
    - 每引用一项: +2.5分
    - 10分封顶

    args:
        patent_count: 专利数量 (用户填写)

    returns:
        float: 专利使用量分
    """
    score = min(patent_count * 2.5, 10.0)
    return score


# 普及地域评分
def calculate_popularity_score(region_coverage: str) -> float:
    """
    计算普及地域分

    全球覆盖(10分)，全国覆盖(7分)，区域覆盖(4分)

    args:
        region_coverage: 普及地域类型 (用户填写)

    returns:
        float: 普及地域分
    """
    coverage_scores = {
        "全球覆盖": 10.0,
        "全国覆盖": 7.0,
        "区域覆盖": 4.0
    }

    return coverage_scores.get(region_coverage, 7.0)


# 侵权记录评分
def calculate_infringement_score(infringement_status: str) -> float:
    """
    计算侵权记录分

    无侵权记录(10分)，历史侵权已解决(6分)，现存纠纷(2分)

    args:
        infringement_status: 侵权记录状态 (用户填写)

    returns:
        float: 侵权记录分
    """
    infringement_scores = {
        "无侵权记录": 10.0,
        "历史侵权已解决": 6.0,
        "现存纠纷": 2.0
    }

    return infringement_scores.get(infringement_status, 6.0)


# 示例使用
if __name__ == "__main__":
    # 创建计算器实例
    calculator = BasicValueB11Calculator()

    # 示例数据
    annual_revenue = [100, 120, 150]  # 近三年收益，单位：万元 (用户填写)
    patent_remaining_years = 8  # 专利剩余年限 (用户填写)
    region_coverage = "全国覆盖"  # 普及地域 (用户填写)
    infringement_status = "无侵权记录"  # 侵权记录 (用户填写)
    patent_count = 2  # 专利数量 (用户填写)
    esg_score = 10.0  # ESG分 (用户填写)
    innovation_ratio = 5.0  # 创新投入比 (用户填写) 创新投入比（研发费用/营收）*100
    target_industry_roe = 0.15  # 目标行业ROE (系统配置)
    benchmark_industry_roe = 0.12  # 基准行业ROE (系统配置)

    # 计算各项指标
    financial_value = calculator.calculate_financial_value_f(annual_revenue)
    patent_score = calculate_patent_score(patent_remaining_years)
    popularity_score = calculate_popularity_score(region_coverage)
    infringement_score = calculate_infringement_score(infringement_status)
    legal_strength = calculator.calculate_legal_strength_l(patent_score, popularity_score, infringement_score)

    patent_usage_score = calculate_patent_usage_score(patent_count)
    development_potential = calculator.calculate_development_potential_d(patent_usage_score, esg_score,
                                                                         innovation_ratio)

    industry_coefficient = calculator.calculate_industry_coefficient_i(target_industry_roe, benchmark_industry_roe)

    # 计算基础价值B11
    basic_value = calculator.calculate_basic_value_b11(
        financial_value, legal_strength, development_potential, industry_coefficient
    )

    print(f"财务价值F: {financial_value:.2f}")
    print(f"法律强度L: {legal_strength:.2f}")
    print(f"发展潜力D: {development_potential:.2f}")
    print(f"行业系数I: {industry_coefficient:.4f}")
    print(f"基础价值B11: {basic_value:.2f}")
