import numpy as np
from scipy.integrate import simpson

from processing import processing
(signal_dwt , waves_dwt , rpeaks , ecg_signal,
 signal, signal.v, signal.fs, rows_to_extract, t_ecg, t_ppg,
 on_column_list, on_column_list_toArea, on_values, on_values_toArea,
 sp_column_list, sp_values, dn_column_list, dn_values, dp_column_list,
 dp_values, u_column_list, u_column_list_toArea, u_values, u_values_toArea,
 v_column_list, v_values, w_column_list, w_values, a_column_list, a_column_list_toArea,
 a_values, a_values_toArea, b_column_list, b_values, c_column_list, c_values,
 e_column_list, e_values, f_column_list, f_values,
 signal.ppg, signal.vpg, signal.apg, signal.jpg) = processing()

from ppg_peaks_val import ppg_peaks_val
(on, on_toArea, sp, dn, dp,
on_values, on_toArea_values, sp_values, dn_values, dp_values,
u, u_toArea, v, w,
u_values, u_toArea_values, v_values, w_values,
a, a_toArea, b, c, e, f,
a_values, a_toArea_values, b_values, c_values, e_values, f_values) = ppg_peaks_val()


def ppg_areas():
    

    # 初始化'on'波之间周期的面积列表
    ppg_areas_values = []

    # 遍历'on'波的索引，计算每个周期的面积
    for i in range(len(on_toArea) - 1):
        start_idx = on_toArea[i]
        end_idx = on_toArea[i + 1]
        
        # 提取当前周期的PPG信号
        current_ppg_segment = signal.ppg[start_idx:end_idx]
        # 创建时间向量
        t_segment = t_ppg[start_idx:end_idx]
        
        # 当前'on'波和下一个'on'波的纵坐标和横坐标
        y_start = on_toArea_values[i]
        x_start = t_ppg[start_idx]
        y_end = on_toArea_values[i + 1]
        x_end = t_ppg[end_idx]
        
        # 计算基线的斜率和截距
        m = (y_end - y_start) / (x_end - x_start)
        b = y_start - m * x_start
        
        # 生成基线信号
        baseline_segment = m * t_segment + b
        
        # 计算相对于基线的PPG信号
        diff_signal = current_ppg_segment - baseline_segment
        
        # 使用辛普森法计算面积
        if len(diff_signal) == 0 or len(t_segment) == 0:
            continue  # 跳过空的信号或时间片段
        
        area = simpson(diff_signal, t_segment)
        ppg_areas_values.append(area)

    # print("ppg_areas:",ppg_areas_values)

    # 初始化'u'波之间周期的面积列表
    vpg_areas_values = []

    # 遍历'u'波的索引，计算每个周期的VPG信号相对于基线的面积
    for i in range(len(u_toArea) - 1):
        start_idx = u_toArea[i]
        end_idx = u_toArea[i + 1]
        
        # 提取当前周期的VPG信号
        current_vpg_segment = signal.vpg[start_idx:end_idx]
        # 创建时间向量
        t_segment = t_ppg[start_idx:end_idx]
        
        # 当前'u'波和下一个'u'波的纵坐标和横坐标
        y_start = u_toArea_values[i]
        x_start = t_ppg[start_idx]
        y_end = u_toArea_values[i + 1]
        x_end = t_ppg[end_idx]
        
        # 计算基线的斜率和截距
        m = (y_end - y_start) / (x_end - x_start)
        b = y_start - m * x_start
        
        # 生成基线信号
        baseline_segment = m * t_segment + b
        
        # 计算相对于基线的VPG信号
        diff_signal = current_vpg_segment - baseline_segment
        
        # 使用辛普森法计算面积
        if len(diff_signal) == 0 or len(t_segment) == 0:
            continue  # 跳过空的信号或时间片段
        
        area = simpson(diff_signal, t_segment)
        vpg_areas_values.append(area)

    # print("vpg_areas:", vpg_areas_values)

    # 初始化'a'波之间周期的面积列表
    apg_areas_values = []

    # 遍历'a'波的索引，计算每个周期的APG信号相对于基线的面积
    for i in range(len(a_toArea) - 1):
        start_idx = a_toArea[i]
        end_idx = a_toArea[i + 1]
        
        # 提取当前周期的APG信号
        current_apg_segment = signal.apg[start_idx:end_idx]
        # 创建时间向量
        t_segment = t_ppg[start_idx:end_idx]
        
        # 当前'a'波和下一个'a'波的纵坐标和横坐标
        y_start = a_toArea_values[i]
        x_start = t_ppg[start_idx]
        y_end = a_toArea_values[i + 1]
        x_end = t_ppg[end_idx]
        
        # 计算基线的斜率和截距
        m = (y_end - y_start) / (x_end - x_start)
        b = y_start - m * x_start
        
        # 生成基线信号
        baseline_segment = m * t_segment + b
        
        # 计算相对于基线的APG信号
        diff_signal = current_apg_segment - baseline_segment
        
        # 使用辛普森法计算面积
        if len(diff_signal) == 0 or len(t_segment) == 0:
            continue  # 跳过空的信号或时间片段
        
        area = simpson(diff_signal, t_segment)
        apg_areas_values.append(area)

    # print("apg_areas:", apg_areas_values)

    # 定义包含所有区域值的字典
    areas_values = {
        "ppg_areas": ppg_areas_values,
        "vpg_areas": vpg_areas_values,
        "apg_areas": apg_areas_values,
    }

    # 计算比值并存储在新字典中
    ratios_areas = {}
    for start_label, start_values in areas_values.items():
        for end_label, end_values in areas_values.items():
            if start_label != end_label:
                ratio_label = f"{start_label}/{end_label}"
                # 计算对应位置的比值
                ratios = [start_val / end_val for start_val, end_val in zip(start_values, end_values)]
                ratios_areas[ratio_label] = ratios
    # print("ratios_areas:",ratios_areas)

    # 计算差值并存储在新字典中
    diffs_areas = {}
    for start_label, start_values in areas_values.items():
        for end_label, end_values in areas_values.items():
            if start_label != end_label:
                diff_label = f"{start_label}-{end_label}"
                # 计算对应位置的差值
                diffs = [abs(start_val - end_val) for start_val, end_val in zip(start_values, end_values)]
                diffs_areas[diff_label] = diffs
    # print("diffs_areas:",diffs_areas)

    return areas_values, ratios_areas, diffs_areas

if __name__ == "__main__":
    ppg_areas()